# Generated from Lcypher.g4 by ANTLR 4.13.2
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO

def serializedATN():
    return [
        4,1,133,1594,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,
        7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,
        13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,
        20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,
        26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,
        33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,
        39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,
        46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,
        52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,
        59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,
        65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,
        72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,
        78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,
        85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,
        91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,
        98,7,98,2,99,7,99,1,0,3,0,202,8,0,1,0,1,0,3,0,206,8,0,1,0,3,0,209,
        8,0,1,0,3,0,212,8,0,1,0,1,0,1,1,1,1,1,1,3,1,219,8,1,1,1,1,1,1,1,
        3,1,224,8,1,1,1,3,1,227,8,1,1,2,1,2,3,2,231,8,2,1,3,1,3,3,3,235,
        8,3,1,3,5,3,238,8,3,10,3,12,3,241,9,3,1,4,1,4,1,4,1,4,3,4,247,8,
        4,1,4,1,4,1,4,3,4,252,8,4,1,4,3,4,255,8,4,1,5,1,5,3,5,259,8,5,1,
        6,1,6,3,6,263,8,6,5,6,265,8,6,10,6,12,6,268,9,6,1,6,1,6,1,6,3,6,
        273,8,6,5,6,275,8,6,10,6,12,6,278,9,6,1,6,1,6,3,6,282,8,6,1,6,5,
        6,285,8,6,10,6,12,6,288,9,6,1,6,3,6,291,8,6,1,6,3,6,294,8,6,3,6,
        296,8,6,1,7,1,7,3,7,300,8,7,5,7,302,8,7,10,7,12,7,305,9,7,1,7,1,
        7,3,7,309,8,7,5,7,311,8,7,10,7,12,7,314,9,7,1,7,1,7,3,7,318,8,7,
        4,7,320,8,7,11,7,12,7,321,1,7,1,7,1,8,1,8,1,8,1,8,1,8,3,8,331,8,
        8,1,9,1,9,1,9,3,9,336,8,9,1,10,1,10,3,10,340,8,10,1,10,1,10,3,10,
        344,8,10,1,10,1,10,3,10,348,8,10,1,10,5,10,351,8,10,10,10,12,10,
        354,9,10,1,10,3,10,357,8,10,1,10,3,10,360,8,10,1,11,1,11,3,11,364,
        8,11,1,11,1,11,1,11,1,11,1,11,1,11,1,12,1,12,3,12,374,8,12,1,12,
        1,12,1,12,5,12,379,8,12,10,12,12,12,382,9,12,1,13,1,13,1,13,1,13,
        1,13,1,13,1,13,1,13,1,13,1,13,3,13,394,8,13,1,14,1,14,3,14,398,8,
        14,1,14,1,14,1,15,1,15,3,15,404,8,15,1,15,1,15,3,15,408,8,15,1,15,
        1,15,3,15,412,8,15,1,15,5,15,415,8,15,10,15,12,15,418,9,15,1,16,
        1,16,3,16,422,8,16,1,16,1,16,3,16,426,8,16,1,16,1,16,1,16,1,16,3,
        16,432,8,16,1,16,1,16,3,16,436,8,16,1,16,1,16,1,16,1,16,3,16,442,
        8,16,1,16,1,16,3,16,446,8,16,1,16,1,16,1,16,1,16,3,16,452,8,16,1,
        16,1,16,3,16,456,8,16,1,17,1,17,3,17,460,8,17,1,17,1,17,3,17,464,
        8,17,1,17,1,17,3,17,468,8,17,1,17,1,17,3,17,472,8,17,1,17,5,17,475,
        8,17,10,17,12,17,478,9,17,1,18,1,18,1,18,1,18,3,18,484,8,18,1,18,
        1,18,3,18,488,8,18,1,18,5,18,491,8,18,10,18,12,18,494,9,18,1,19,
        1,19,1,19,1,19,3,19,500,8,19,1,20,1,20,1,20,1,20,3,20,506,8,20,1,
        20,1,20,1,20,3,20,511,8,20,1,21,1,21,1,21,1,21,3,21,517,8,21,1,21,
        1,21,1,21,1,21,3,21,523,8,21,1,22,1,22,1,22,3,22,528,8,22,1,22,1,
        22,3,22,532,8,22,1,22,5,22,535,8,22,10,22,12,22,538,9,22,3,22,540,
        8,22,1,22,3,22,543,8,22,1,22,3,22,546,8,22,1,23,1,23,1,23,1,23,1,
        23,3,23,553,8,23,1,23,1,23,1,24,1,24,3,24,559,8,24,1,24,3,24,562,
        8,24,1,24,1,24,1,24,3,24,567,8,24,1,24,3,24,570,8,24,1,25,1,25,3,
        25,574,8,25,1,25,3,25,577,8,25,1,25,1,25,1,25,1,26,1,26,1,26,3,26,
        585,8,26,1,26,1,26,3,26,589,8,26,1,26,1,26,3,26,593,8,26,1,27,1,
        27,3,27,597,8,27,1,27,1,27,3,27,601,8,27,1,27,5,27,604,8,27,10,27,
        12,27,607,9,27,1,27,1,27,3,27,611,8,27,1,27,1,27,3,27,615,8,27,1,
        27,5,27,618,8,27,10,27,12,27,621,9,27,3,27,623,8,27,1,28,1,28,1,
        28,1,28,1,28,1,28,1,28,3,28,632,8,28,1,29,1,29,1,29,1,29,1,29,1,
        29,1,29,3,29,641,8,29,1,29,5,29,644,8,29,10,29,12,29,647,9,29,1,
        30,1,30,1,30,1,30,1,31,1,31,1,31,1,31,1,32,1,32,3,32,659,8,32,1,
        32,3,32,662,8,32,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,33,1,
        33,1,33,1,33,1,33,1,33,3,33,678,8,33,1,34,1,34,1,34,1,34,1,35,1,
        35,3,35,686,8,35,1,35,1,35,3,35,690,8,35,1,35,5,35,693,8,35,10,35,
        12,35,696,9,35,1,36,1,36,3,36,700,8,36,1,36,1,36,3,36,704,8,36,1,
        36,1,36,1,36,3,36,709,8,36,1,37,1,37,1,38,1,38,3,38,715,8,38,1,38,
        5,38,718,8,38,10,38,12,38,721,9,38,1,38,1,38,1,38,1,38,3,38,727,
        8,38,1,39,1,39,3,39,731,8,39,1,39,1,39,3,39,735,8,39,3,39,737,8,
        39,1,39,1,39,3,39,741,8,39,3,39,743,8,39,1,39,1,39,3,39,747,8,39,
        3,39,749,8,39,1,39,1,39,1,40,1,40,3,40,755,8,40,1,40,1,40,1,41,1,
        41,3,41,761,8,41,1,41,1,41,3,41,765,8,41,1,41,3,41,768,8,41,1,41,
        3,41,771,8,41,1,41,1,41,3,41,775,8,41,1,41,1,41,1,41,1,41,3,41,781,
        8,41,1,41,1,41,3,41,785,8,41,1,41,3,41,788,8,41,1,41,3,41,791,8,
        41,1,41,1,41,1,41,1,41,3,41,797,8,41,1,41,3,41,800,8,41,1,41,3,41,
        803,8,41,1,41,1,41,3,41,807,8,41,1,41,1,41,1,41,1,41,3,41,813,8,
        41,1,41,3,41,816,8,41,1,41,3,41,819,8,41,1,41,1,41,3,41,823,8,41,
        1,42,1,42,3,42,827,8,42,1,42,1,42,3,42,831,8,42,3,42,833,8,42,1,
        42,1,42,3,42,837,8,42,3,42,839,8,42,1,42,3,42,842,8,42,1,42,1,42,
        3,42,846,8,42,3,42,848,8,42,1,42,1,42,1,43,1,43,3,43,854,8,43,1,
        44,1,44,3,44,858,8,44,1,44,1,44,3,44,862,8,44,1,44,1,44,3,44,866,
        8,44,1,44,3,44,869,8,44,1,44,5,44,872,8,44,10,44,12,44,875,9,44,
        1,45,1,45,3,45,879,8,45,1,45,5,45,882,8,45,10,45,12,45,885,9,45,
        1,46,1,46,3,46,889,8,46,1,46,1,46,1,47,1,47,3,47,895,8,47,1,47,1,
        47,3,47,899,8,47,3,47,901,8,47,1,47,1,47,3,47,905,8,47,1,47,1,47,
        3,47,909,8,47,3,47,911,8,47,3,47,913,8,47,1,48,1,48,1,49,1,49,1,
        50,1,50,1,51,1,51,1,51,1,51,1,51,5,51,926,8,51,10,51,12,51,929,9,
        51,1,52,1,52,1,52,1,52,1,52,5,52,936,8,52,10,52,12,52,939,9,52,1,
        53,1,53,1,53,1,53,1,53,5,53,946,8,53,10,53,12,53,949,9,53,1,54,1,
        54,3,54,953,8,54,5,54,955,8,54,10,54,12,54,958,9,54,1,54,1,54,1,
        55,1,55,3,55,964,8,55,1,55,5,55,967,8,55,10,55,12,55,970,9,55,1,
        56,1,56,3,56,974,8,56,1,56,1,56,3,56,978,8,56,1,56,1,56,3,56,982,
        8,56,1,56,1,56,3,56,986,8,56,1,56,5,56,989,8,56,10,56,12,56,992,
        9,56,1,57,1,57,3,57,996,8,57,1,57,1,57,3,57,1000,8,57,1,57,1,57,
        3,57,1004,8,57,1,57,1,57,3,57,1008,8,57,1,57,1,57,3,57,1012,8,57,
        1,57,1,57,3,57,1016,8,57,1,57,5,57,1019,8,57,10,57,12,57,1022,9,
        57,1,58,1,58,3,58,1026,8,58,1,58,1,58,3,58,1030,8,58,1,58,5,58,1033,
        8,58,10,58,12,58,1036,9,58,1,59,1,59,3,59,1040,8,59,5,59,1042,8,
        59,10,59,12,59,1045,9,59,1,59,1,59,1,60,1,60,1,60,1,60,5,60,1053,
        8,60,10,60,12,60,1056,9,60,1,61,1,61,1,61,3,61,1061,8,61,1,61,1,
        61,3,61,1065,8,61,1,61,1,61,1,61,1,61,1,61,3,61,1072,8,61,1,61,1,
        61,3,61,1076,8,61,1,61,1,61,3,61,1080,8,61,1,61,3,61,1083,8,61,1,
        62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,1,62,3,62,1097,
        8,62,1,62,3,62,1100,8,62,1,62,1,62,1,63,1,63,1,63,1,63,1,63,1,63,
        1,63,1,63,1,63,1,63,3,63,1114,8,63,1,64,1,64,3,64,1118,8,64,1,64,
        5,64,1121,8,64,10,64,12,64,1124,9,64,1,64,3,64,1127,8,64,1,64,3,
        64,1130,8,64,1,65,1,65,1,65,1,65,1,65,3,65,1137,8,65,1,65,1,65,3,
        65,1141,8,65,1,65,1,65,3,65,1145,8,65,1,65,1,65,1,65,1,65,1,65,3,
        65,1152,8,65,1,65,1,65,3,65,1156,8,65,1,65,1,65,3,65,1160,8,65,1,
        65,1,65,1,65,1,65,3,65,1166,8,65,1,65,1,65,3,65,1170,8,65,1,65,1,
        65,3,65,1174,8,65,1,65,1,65,1,65,1,65,3,65,1180,8,65,1,65,1,65,3,
        65,1184,8,65,1,65,1,65,3,65,1188,8,65,1,65,1,65,1,65,1,65,3,65,1194,
        8,65,1,65,1,65,3,65,1198,8,65,1,65,1,65,3,65,1202,8,65,1,65,1,65,
        1,65,1,65,1,65,1,65,3,65,1210,8,65,1,66,1,66,1,66,1,66,1,66,1,66,
        3,66,1218,8,66,1,67,1,67,1,68,1,68,3,68,1224,8,68,1,68,1,68,3,68,
        1228,8,68,1,68,1,68,3,68,1232,8,68,1,68,1,68,3,68,1236,8,68,5,68,
        1238,8,68,10,68,12,68,1241,9,68,3,68,1243,8,68,1,68,1,68,1,69,1,
        69,3,69,1249,8,69,1,69,1,69,1,69,3,69,1254,8,69,1,69,1,69,1,69,3,
        69,1259,8,69,1,69,1,69,1,69,3,69,1264,8,69,1,69,1,69,1,69,3,69,1269,
        8,69,1,69,1,69,1,69,3,69,1274,8,69,1,69,3,69,1277,8,69,1,70,1,70,
        3,70,1281,8,70,1,70,1,70,3,70,1285,8,70,1,70,1,70,1,71,1,71,3,71,
        1291,8,71,1,71,4,71,1294,8,71,11,71,12,71,1295,1,72,1,72,3,72,1300,
        8,72,1,72,3,72,1303,8,72,1,73,1,73,1,73,1,73,1,73,1,73,1,74,1,74,
        3,74,1313,8,74,1,74,1,74,3,74,1317,8,74,1,74,1,74,3,74,1321,8,74,
        3,74,1323,8,74,1,74,1,74,3,74,1327,8,74,1,74,1,74,3,74,1331,8,74,
        1,74,1,74,3,74,1335,8,74,5,74,1337,8,74,10,74,12,74,1340,9,74,3,
        74,1342,8,74,1,74,1,74,1,75,1,75,1,75,1,75,3,75,1350,8,75,1,76,1,
        76,3,76,1354,8,76,1,76,1,76,3,76,1358,8,76,1,76,1,76,3,76,1362,8,
        76,1,76,1,76,3,76,1366,8,76,1,76,1,76,3,76,1370,8,76,5,76,1372,8,
        76,10,76,12,76,1375,9,76,3,76,1377,8,76,1,76,1,76,1,77,1,77,1,78,
        1,78,1,79,1,79,1,79,1,80,1,80,1,80,5,80,1391,8,80,10,80,12,80,1394,
        9,80,1,81,1,81,3,81,1398,8,81,1,81,1,81,3,81,1402,8,81,1,81,1,81,
        3,81,1406,8,81,1,81,3,81,1409,8,81,1,81,3,81,1412,8,81,1,81,1,81,
        1,82,1,82,3,82,1418,8,82,1,82,1,82,3,82,1422,8,82,1,82,1,82,3,82,
        1426,8,82,3,82,1428,8,82,1,82,1,82,3,82,1432,8,82,1,82,1,82,3,82,
        1436,8,82,1,82,1,82,3,82,1440,8,82,3,82,1442,8,82,1,82,1,82,3,82,
        1446,8,82,1,82,1,82,3,82,1450,8,82,1,82,1,82,1,83,1,83,3,83,1456,
        8,83,1,83,1,83,1,84,1,84,3,84,1462,8,84,1,84,4,84,1465,8,84,11,84,
        12,84,1466,1,84,1,84,3,84,1471,8,84,1,84,1,84,3,84,1475,8,84,1,84,
        4,84,1478,8,84,11,84,12,84,1479,3,84,1482,8,84,1,84,3,84,1485,8,
        84,1,84,1,84,3,84,1489,8,84,1,84,3,84,1492,8,84,1,84,3,84,1495,8,
        84,1,84,1,84,1,85,1,85,3,85,1501,8,85,1,85,1,85,3,85,1505,8,85,1,
        85,1,85,3,85,1509,8,85,1,85,1,85,1,86,1,86,1,87,1,87,3,87,1517,8,
        87,1,88,1,88,3,88,1521,8,88,1,88,1,88,3,88,1525,8,88,1,88,1,88,3,
        88,1529,8,88,1,88,1,88,3,88,1533,8,88,1,88,1,88,3,88,1537,8,88,1,
        88,1,88,3,88,1541,8,88,1,88,1,88,3,88,1545,8,88,1,88,1,88,3,88,1549,
        8,88,5,88,1551,8,88,10,88,12,88,1554,9,88,3,88,1556,8,88,1,88,1,
        88,1,89,1,89,1,89,3,89,1563,8,89,1,90,1,90,3,90,1567,8,90,1,90,4,
        90,1570,8,90,11,90,12,90,1571,1,91,1,91,1,92,1,92,1,93,1,93,1,94,
        1,94,3,94,1582,8,94,1,95,1,95,1,96,1,96,1,97,1,97,1,98,1,98,1,99,
        1,99,1,99,0,0,100,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,
        34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,
        78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,
        116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,
        148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,
        180,182,184,186,188,190,192,194,196,198,0,10,1,0,70,73,1,0,13,14,
        1,0,93,94,1,0,103,105,1,0,113,114,4,0,89,92,106,106,115,117,130,
        130,6,0,48,60,63,73,77,85,87,88,93,100,118,127,2,0,19,19,27,30,2,
        0,20,20,31,34,2,0,14,14,35,45,1820,0,201,1,0,0,0,2,226,1,0,0,0,4,
        230,1,0,0,0,6,232,1,0,0,0,8,254,1,0,0,0,10,258,1,0,0,0,12,295,1,
        0,0,0,14,319,1,0,0,0,16,330,1,0,0,0,18,335,1,0,0,0,20,339,1,0,0,
        0,22,361,1,0,0,0,24,371,1,0,0,0,26,393,1,0,0,0,28,395,1,0,0,0,30,
        401,1,0,0,0,32,455,1,0,0,0,34,459,1,0,0,0,36,479,1,0,0,0,38,499,
        1,0,0,0,40,501,1,0,0,0,42,512,1,0,0,0,44,539,1,0,0,0,46,552,1,0,
        0,0,48,556,1,0,0,0,50,571,1,0,0,0,52,581,1,0,0,0,54,622,1,0,0,0,
        56,631,1,0,0,0,58,633,1,0,0,0,60,648,1,0,0,0,62,652,1,0,0,0,64,656,
        1,0,0,0,66,677,1,0,0,0,68,679,1,0,0,0,70,683,1,0,0,0,72,708,1,0,
        0,0,74,710,1,0,0,0,76,726,1,0,0,0,78,728,1,0,0,0,80,752,1,0,0,0,
        82,822,1,0,0,0,84,824,1,0,0,0,86,853,1,0,0,0,88,855,1,0,0,0,90,876,
        1,0,0,0,92,886,1,0,0,0,94,892,1,0,0,0,96,914,1,0,0,0,98,916,1,0,
        0,0,100,918,1,0,0,0,102,920,1,0,0,0,104,930,1,0,0,0,106,940,1,0,
        0,0,108,956,1,0,0,0,110,961,1,0,0,0,112,971,1,0,0,0,114,993,1,0,
        0,0,116,1023,1,0,0,0,118,1043,1,0,0,0,120,1048,1,0,0,0,122,1082,
        1,0,0,0,124,1096,1,0,0,0,126,1113,1,0,0,0,128,1115,1,0,0,0,130,1209,
        1,0,0,0,132,1217,1,0,0,0,134,1219,1,0,0,0,136,1221,1,0,0,0,138,1276,
        1,0,0,0,140,1278,1,0,0,0,142,1288,1,0,0,0,144,1297,1,0,0,0,146,1304,
        1,0,0,0,148,1310,1,0,0,0,150,1349,1,0,0,0,152,1351,1,0,0,0,154,1380,
        1,0,0,0,156,1382,1,0,0,0,158,1384,1,0,0,0,160,1392,1,0,0,0,162,1395,
        1,0,0,0,164,1415,1,0,0,0,166,1453,1,0,0,0,168,1481,1,0,0,0,170,1498,
        1,0,0,0,172,1512,1,0,0,0,174,1516,1,0,0,0,176,1518,1,0,0,0,178,1559,
        1,0,0,0,180,1564,1,0,0,0,182,1573,1,0,0,0,184,1575,1,0,0,0,186,1577,
        1,0,0,0,188,1581,1,0,0,0,190,1583,1,0,0,0,192,1585,1,0,0,0,194,1587,
        1,0,0,0,196,1589,1,0,0,0,198,1591,1,0,0,0,200,202,5,131,0,0,201,
        200,1,0,0,0,201,202,1,0,0,0,202,203,1,0,0,0,203,208,3,2,1,0,204,
        206,5,131,0,0,205,204,1,0,0,0,205,206,1,0,0,0,206,207,1,0,0,0,207,
        209,5,1,0,0,208,205,1,0,0,0,208,209,1,0,0,0,209,211,1,0,0,0,210,
        212,5,131,0,0,211,210,1,0,0,0,211,212,1,0,0,0,212,213,1,0,0,0,213,
        214,5,0,0,1,214,1,1,0,0,0,215,227,3,4,2,0,216,218,5,46,0,0,217,219,
        5,131,0,0,218,217,1,0,0,0,218,219,1,0,0,0,219,220,1,0,0,0,220,227,
        3,4,2,0,221,223,5,47,0,0,222,224,5,131,0,0,223,222,1,0,0,0,223,224,
        1,0,0,0,224,225,1,0,0,0,225,227,3,4,2,0,226,215,1,0,0,0,226,216,
        1,0,0,0,226,221,1,0,0,0,227,3,1,0,0,0,228,231,3,6,3,0,229,231,3,
        42,21,0,230,228,1,0,0,0,230,229,1,0,0,0,231,5,1,0,0,0,232,239,3,
        10,5,0,233,235,5,131,0,0,234,233,1,0,0,0,234,235,1,0,0,0,235,236,
        1,0,0,0,236,238,3,8,4,0,237,234,1,0,0,0,238,241,1,0,0,0,239,237,
        1,0,0,0,239,240,1,0,0,0,240,7,1,0,0,0,241,239,1,0,0,0,242,243,5,
        48,0,0,243,244,5,131,0,0,244,246,5,49,0,0,245,247,5,131,0,0,246,
        245,1,0,0,0,246,247,1,0,0,0,247,248,1,0,0,0,248,255,3,10,5,0,249,
        251,5,48,0,0,250,252,5,131,0,0,251,250,1,0,0,0,251,252,1,0,0,0,252,
        253,1,0,0,0,253,255,3,10,5,0,254,242,1,0,0,0,254,249,1,0,0,0,255,
        9,1,0,0,0,256,259,3,12,6,0,257,259,3,14,7,0,258,256,1,0,0,0,258,
        257,1,0,0,0,259,11,1,0,0,0,260,262,3,18,9,0,261,263,5,131,0,0,262,
        261,1,0,0,0,262,263,1,0,0,0,263,265,1,0,0,0,264,260,1,0,0,0,265,
        268,1,0,0,0,266,264,1,0,0,0,266,267,1,0,0,0,267,269,1,0,0,0,268,
        266,1,0,0,0,269,296,3,50,25,0,270,272,3,18,9,0,271,273,5,131,0,0,
        272,271,1,0,0,0,272,273,1,0,0,0,273,275,1,0,0,0,274,270,1,0,0,0,
        275,278,1,0,0,0,276,274,1,0,0,0,276,277,1,0,0,0,277,279,1,0,0,0,
        278,276,1,0,0,0,279,286,3,16,8,0,280,282,5,131,0,0,281,280,1,0,0,
        0,281,282,1,0,0,0,282,283,1,0,0,0,283,285,3,16,8,0,284,281,1,0,0,
        0,285,288,1,0,0,0,286,284,1,0,0,0,286,287,1,0,0,0,287,293,1,0,0,
        0,288,286,1,0,0,0,289,291,5,131,0,0,290,289,1,0,0,0,290,291,1,0,
        0,0,291,292,1,0,0,0,292,294,3,50,25,0,293,290,1,0,0,0,293,294,1,
        0,0,0,294,296,1,0,0,0,295,266,1,0,0,0,295,276,1,0,0,0,296,13,1,0,
        0,0,297,299,3,18,9,0,298,300,5,131,0,0,299,298,1,0,0,0,299,300,1,
        0,0,0,300,302,1,0,0,0,301,297,1,0,0,0,302,305,1,0,0,0,303,301,1,
        0,0,0,303,304,1,0,0,0,304,312,1,0,0,0,305,303,1,0,0,0,306,308,3,
        16,8,0,307,309,5,131,0,0,308,307,1,0,0,0,308,309,1,0,0,0,309,311,
        1,0,0,0,310,306,1,0,0,0,311,314,1,0,0,0,312,310,1,0,0,0,312,313,
        1,0,0,0,313,315,1,0,0,0,314,312,1,0,0,0,315,317,3,48,24,0,316,318,
        5,131,0,0,317,316,1,0,0,0,317,318,1,0,0,0,318,320,1,0,0,0,319,303,
        1,0,0,0,320,321,1,0,0,0,321,319,1,0,0,0,321,322,1,0,0,0,322,323,
        1,0,0,0,323,324,3,12,6,0,324,15,1,0,0,0,325,331,3,28,14,0,326,331,
        3,24,12,0,327,331,3,34,17,0,328,331,3,30,15,0,329,331,3,36,18,0,
        330,325,1,0,0,0,330,326,1,0,0,0,330,327,1,0,0,0,330,328,1,0,0,0,
        330,329,1,0,0,0,331,17,1,0,0,0,332,336,3,20,10,0,333,336,3,22,11,
        0,334,336,3,40,20,0,335,332,1,0,0,0,335,333,1,0,0,0,335,334,1,0,
        0,0,336,19,1,0,0,0,337,338,5,50,0,0,338,340,5,131,0,0,339,337,1,
        0,0,0,339,340,1,0,0,0,340,341,1,0,0,0,341,343,5,51,0,0,342,344,5,
        131,0,0,343,342,1,0,0,0,343,344,1,0,0,0,344,345,1,0,0,0,345,352,
        3,70,35,0,346,348,5,131,0,0,347,346,1,0,0,0,347,348,1,0,0,0,348,
        349,1,0,0,0,349,351,3,66,33,0,350,347,1,0,0,0,351,354,1,0,0,0,352,
        350,1,0,0,0,352,353,1,0,0,0,353,359,1,0,0,0,354,352,1,0,0,0,355,
        357,5,131,0,0,356,355,1,0,0,0,356,357,1,0,0,0,357,358,1,0,0,0,358,
        360,3,68,34,0,359,356,1,0,0,0,359,360,1,0,0,0,360,21,1,0,0,0,361,
        363,5,52,0,0,362,364,5,131,0,0,363,362,1,0,0,0,363,364,1,0,0,0,364,
        365,1,0,0,0,365,366,3,100,50,0,366,367,5,131,0,0,367,368,5,53,0,
        0,368,369,5,131,0,0,369,370,3,172,86,0,370,23,1,0,0,0,371,373,5,
        54,0,0,372,374,5,131,0,0,373,372,1,0,0,0,373,374,1,0,0,0,374,375,
        1,0,0,0,375,380,3,72,36,0,376,377,5,131,0,0,377,379,3,26,13,0,378,
        376,1,0,0,0,379,382,1,0,0,0,380,378,1,0,0,0,380,381,1,0,0,0,381,
        25,1,0,0,0,382,380,1,0,0,0,383,384,5,55,0,0,384,385,5,131,0,0,385,
        386,5,51,0,0,386,387,5,131,0,0,387,394,3,30,15,0,388,389,5,55,0,
        0,389,390,5,131,0,0,390,391,5,56,0,0,391,392,5,131,0,0,392,394,3,
        30,15,0,393,383,1,0,0,0,393,388,1,0,0,0,394,27,1,0,0,0,395,397,5,
        56,0,0,396,398,5,131,0,0,397,396,1,0,0,0,397,398,1,0,0,0,398,399,
        1,0,0,0,399,400,3,70,35,0,400,29,1,0,0,0,401,403,5,57,0,0,402,404,
        5,131,0,0,403,402,1,0,0,0,403,404,1,0,0,0,404,405,1,0,0,0,405,416,
        3,32,16,0,406,408,5,131,0,0,407,406,1,0,0,0,407,408,1,0,0,0,408,
        409,1,0,0,0,409,411,5,2,0,0,410,412,5,131,0,0,411,410,1,0,0,0,411,
        412,1,0,0,0,412,413,1,0,0,0,413,415,3,32,16,0,414,407,1,0,0,0,415,
        418,1,0,0,0,416,414,1,0,0,0,416,417,1,0,0,0,417,31,1,0,0,0,418,416,
        1,0,0,0,419,421,3,180,90,0,420,422,5,131,0,0,421,420,1,0,0,0,421,
        422,1,0,0,0,422,423,1,0,0,0,423,425,5,3,0,0,424,426,5,131,0,0,425,
        424,1,0,0,0,425,426,1,0,0,0,426,427,1,0,0,0,427,428,3,100,50,0,428,
        456,1,0,0,0,429,431,3,172,86,0,430,432,5,131,0,0,431,430,1,0,0,0,
        431,432,1,0,0,0,432,433,1,0,0,0,433,435,5,3,0,0,434,436,5,131,0,
        0,435,434,1,0,0,0,435,436,1,0,0,0,436,437,1,0,0,0,437,438,3,100,
        50,0,438,456,1,0,0,0,439,441,3,172,86,0,440,442,5,131,0,0,441,440,
        1,0,0,0,441,442,1,0,0,0,442,443,1,0,0,0,443,445,5,4,0,0,444,446,
        5,131,0,0,445,444,1,0,0,0,445,446,1,0,0,0,446,447,1,0,0,0,447,448,
        3,100,50,0,448,456,1,0,0,0,449,451,3,172,86,0,450,452,5,131,0,0,
        451,450,1,0,0,0,451,452,1,0,0,0,452,453,1,0,0,0,453,454,3,90,45,
        0,454,456,1,0,0,0,455,419,1,0,0,0,455,429,1,0,0,0,455,439,1,0,0,
        0,455,449,1,0,0,0,456,33,1,0,0,0,457,458,5,58,0,0,458,460,5,131,
        0,0,459,457,1,0,0,0,459,460,1,0,0,0,460,461,1,0,0,0,461,463,5,59,
        0,0,462,464,5,131,0,0,463,462,1,0,0,0,463,464,1,0,0,0,464,465,1,
        0,0,0,465,476,3,100,50,0,466,468,5,131,0,0,467,466,1,0,0,0,467,468,
        1,0,0,0,468,469,1,0,0,0,469,471,5,2,0,0,470,472,5,131,0,0,471,470,
        1,0,0,0,471,472,1,0,0,0,472,473,1,0,0,0,473,475,3,100,50,0,474,467,
        1,0,0,0,475,478,1,0,0,0,476,474,1,0,0,0,476,477,1,0,0,0,477,35,1,
        0,0,0,478,476,1,0,0,0,479,480,5,60,0,0,480,481,5,131,0,0,481,492,
        3,38,19,0,482,484,5,131,0,0,483,482,1,0,0,0,483,484,1,0,0,0,484,
        485,1,0,0,0,485,487,5,2,0,0,486,488,5,131,0,0,487,486,1,0,0,0,487,
        488,1,0,0,0,488,489,1,0,0,0,489,491,3,38,19,0,490,483,1,0,0,0,491,
        494,1,0,0,0,492,490,1,0,0,0,492,493,1,0,0,0,493,37,1,0,0,0,494,492,
        1,0,0,0,495,496,3,172,86,0,496,497,3,90,45,0,497,500,1,0,0,0,498,
        500,3,180,90,0,499,495,1,0,0,0,499,498,1,0,0,0,500,39,1,0,0,0,501,
        502,5,61,0,0,502,503,5,131,0,0,503,510,3,152,76,0,504,506,5,131,
        0,0,505,504,1,0,0,0,505,506,1,0,0,0,506,507,1,0,0,0,507,508,5,62,
        0,0,508,509,5,131,0,0,509,511,3,44,22,0,510,505,1,0,0,0,510,511,
        1,0,0,0,511,41,1,0,0,0,512,513,5,61,0,0,513,516,5,131,0,0,514,517,
        3,152,76,0,515,517,3,154,77,0,516,514,1,0,0,0,516,515,1,0,0,0,517,
        522,1,0,0,0,518,519,5,131,0,0,519,520,5,62,0,0,520,521,5,131,0,0,
        521,523,3,44,22,0,522,518,1,0,0,0,522,523,1,0,0,0,523,43,1,0,0,0,
        524,540,5,5,0,0,525,536,3,46,23,0,526,528,5,131,0,0,527,526,1,0,
        0,0,527,528,1,0,0,0,528,529,1,0,0,0,529,531,5,2,0,0,530,532,5,131,
        0,0,531,530,1,0,0,0,531,532,1,0,0,0,532,533,1,0,0,0,533,535,3,46,
        23,0,534,527,1,0,0,0,535,538,1,0,0,0,536,534,1,0,0,0,536,537,1,0,
        0,0,537,540,1,0,0,0,538,536,1,0,0,0,539,524,1,0,0,0,539,525,1,0,
        0,0,540,545,1,0,0,0,541,543,5,131,0,0,542,541,1,0,0,0,542,543,1,
        0,0,0,543,544,1,0,0,0,544,546,3,68,34,0,545,542,1,0,0,0,545,546,
        1,0,0,0,546,45,1,0,0,0,547,548,3,156,78,0,548,549,5,131,0,0,549,
        550,5,53,0,0,550,551,5,131,0,0,551,553,1,0,0,0,552,547,1,0,0,0,552,
        553,1,0,0,0,553,554,1,0,0,0,554,555,3,172,86,0,555,47,1,0,0,0,556,
        561,5,63,0,0,557,559,5,131,0,0,558,557,1,0,0,0,558,559,1,0,0,0,559,
        560,1,0,0,0,560,562,5,64,0,0,561,558,1,0,0,0,561,562,1,0,0,0,562,
        563,1,0,0,0,563,564,5,131,0,0,564,569,3,52,26,0,565,567,5,131,0,
        0,566,565,1,0,0,0,566,567,1,0,0,0,567,568,1,0,0,0,568,570,3,68,34,
        0,569,566,1,0,0,0,569,570,1,0,0,0,570,49,1,0,0,0,571,576,5,65,0,
        0,572,574,5,131,0,0,573,572,1,0,0,0,573,574,1,0,0,0,574,575,1,0,
        0,0,575,577,5,64,0,0,576,573,1,0,0,0,576,577,1,0,0,0,577,578,1,0,
        0,0,578,579,5,131,0,0,579,580,3,52,26,0,580,51,1,0,0,0,581,584,3,
        54,27,0,582,583,5,131,0,0,583,585,3,58,29,0,584,582,1,0,0,0,584,
        585,1,0,0,0,585,588,1,0,0,0,586,587,5,131,0,0,587,589,3,60,30,0,
        588,586,1,0,0,0,588,589,1,0,0,0,589,592,1,0,0,0,590,591,5,131,0,
        0,591,593,3,62,31,0,592,590,1,0,0,0,592,593,1,0,0,0,593,53,1,0,0,
        0,594,605,5,5,0,0,595,597,5,131,0,0,596,595,1,0,0,0,596,597,1,0,
        0,0,597,598,1,0,0,0,598,600,5,2,0,0,599,601,5,131,0,0,600,599,1,
        0,0,0,600,601,1,0,0,0,601,602,1,0,0,0,602,604,3,56,28,0,603,596,
        1,0,0,0,604,607,1,0,0,0,605,603,1,0,0,0,605,606,1,0,0,0,606,623,
        1,0,0,0,607,605,1,0,0,0,608,619,3,56,28,0,609,611,5,131,0,0,610,
        609,1,0,0,0,610,611,1,0,0,0,611,612,1,0,0,0,612,614,5,2,0,0,613,
        615,5,131,0,0,614,613,1,0,0,0,614,615,1,0,0,0,615,616,1,0,0,0,616,
        618,3,56,28,0,617,610,1,0,0,0,618,621,1,0,0,0,619,617,1,0,0,0,619,
        620,1,0,0,0,620,623,1,0,0,0,621,619,1,0,0,0,622,594,1,0,0,0,622,
        608,1,0,0,0,623,55,1,0,0,0,624,625,3,100,50,0,625,626,5,131,0,0,
        626,627,5,53,0,0,627,628,5,131,0,0,628,629,3,172,86,0,629,632,1,
        0,0,0,630,632,3,100,50,0,631,624,1,0,0,0,631,630,1,0,0,0,632,57,
        1,0,0,0,633,634,5,66,0,0,634,635,5,131,0,0,635,636,5,67,0,0,636,
        637,5,131,0,0,637,645,3,64,32,0,638,640,5,2,0,0,639,641,5,131,0,
        0,640,639,1,0,0,0,640,641,1,0,0,0,641,642,1,0,0,0,642,644,3,64,32,
        0,643,638,1,0,0,0,644,647,1,0,0,0,645,643,1,0,0,0,645,646,1,0,0,
        0,646,59,1,0,0,0,647,645,1,0,0,0,648,649,5,68,0,0,649,650,5,131,
        0,0,650,651,3,100,50,0,651,61,1,0,0,0,652,653,5,69,0,0,653,654,5,
        131,0,0,654,655,3,100,50,0,655,63,1,0,0,0,656,661,3,100,50,0,657,
        659,5,131,0,0,658,657,1,0,0,0,658,659,1,0,0,0,659,660,1,0,0,0,660,
        662,7,0,0,0,661,658,1,0,0,0,661,662,1,0,0,0,662,65,1,0,0,0,663,664,
        5,74,0,0,664,665,5,131,0,0,665,666,5,75,0,0,666,667,5,131,0,0,667,
        668,5,55,0,0,668,669,5,131,0,0,669,678,3,172,86,0,670,671,5,74,0,
        0,671,672,5,131,0,0,672,673,5,76,0,0,673,674,5,131,0,0,674,675,5,
        55,0,0,675,676,5,131,0,0,676,678,3,172,86,0,677,663,1,0,0,0,677,
        670,1,0,0,0,678,67,1,0,0,0,679,680,5,77,0,0,680,681,5,131,0,0,681,
        682,3,100,50,0,682,69,1,0,0,0,683,694,3,72,36,0,684,686,5,131,0,
        0,685,684,1,0,0,0,685,686,1,0,0,0,686,687,1,0,0,0,687,689,5,2,0,
        0,688,690,5,131,0,0,689,688,1,0,0,0,689,690,1,0,0,0,690,691,1,0,
        0,0,691,693,3,72,36,0,692,685,1,0,0,0,693,696,1,0,0,0,694,692,1,
        0,0,0,694,695,1,0,0,0,695,71,1,0,0,0,696,694,1,0,0,0,697,699,3,172,
        86,0,698,700,5,131,0,0,699,698,1,0,0,0,699,700,1,0,0,0,700,701,1,
        0,0,0,701,703,5,3,0,0,702,704,5,131,0,0,703,702,1,0,0,0,703,704,
        1,0,0,0,704,705,1,0,0,0,705,706,3,74,37,0,706,709,1,0,0,0,707,709,
        3,74,37,0,708,697,1,0,0,0,708,707,1,0,0,0,709,73,1,0,0,0,710,711,
        3,76,38,0,711,75,1,0,0,0,712,719,3,78,39,0,713,715,5,131,0,0,714,
        713,1,0,0,0,714,715,1,0,0,0,715,716,1,0,0,0,716,718,3,80,40,0,717,
        714,1,0,0,0,718,721,1,0,0,0,719,717,1,0,0,0,719,720,1,0,0,0,720,
        727,1,0,0,0,721,719,1,0,0,0,722,723,5,6,0,0,723,724,3,76,38,0,724,
        725,5,7,0,0,725,727,1,0,0,0,726,712,1,0,0,0,726,722,1,0,0,0,727,
        77,1,0,0,0,728,730,5,6,0,0,729,731,5,131,0,0,730,729,1,0,0,0,730,
        731,1,0,0,0,731,736,1,0,0,0,732,734,3,172,86,0,733,735,5,131,0,0,
        734,733,1,0,0,0,734,735,1,0,0,0,735,737,1,0,0,0,736,732,1,0,0,0,
        736,737,1,0,0,0,737,742,1,0,0,0,738,740,3,90,45,0,739,741,5,131,
        0,0,740,739,1,0,0,0,740,741,1,0,0,0,741,743,1,0,0,0,742,738,1,0,
        0,0,742,743,1,0,0,0,743,748,1,0,0,0,744,746,3,86,43,0,745,747,5,
        131,0,0,746,745,1,0,0,0,746,747,1,0,0,0,747,749,1,0,0,0,748,744,
        1,0,0,0,748,749,1,0,0,0,749,750,1,0,0,0,750,751,5,7,0,0,751,79,1,
        0,0,0,752,754,3,82,41,0,753,755,5,131,0,0,754,753,1,0,0,0,754,755,
        1,0,0,0,755,756,1,0,0,0,756,757,3,78,39,0,757,81,1,0,0,0,758,760,
        3,194,97,0,759,761,5,131,0,0,760,759,1,0,0,0,760,761,1,0,0,0,761,
        762,1,0,0,0,762,764,3,198,99,0,763,765,5,131,0,0,764,763,1,0,0,0,
        764,765,1,0,0,0,765,767,1,0,0,0,766,768,3,84,42,0,767,766,1,0,0,
        0,767,768,1,0,0,0,768,770,1,0,0,0,769,771,5,131,0,0,770,769,1,0,
        0,0,770,771,1,0,0,0,771,772,1,0,0,0,772,774,3,198,99,0,773,775,5,
        131,0,0,774,773,1,0,0,0,774,775,1,0,0,0,775,776,1,0,0,0,776,777,
        3,196,98,0,777,823,1,0,0,0,778,780,3,194,97,0,779,781,5,131,0,0,
        780,779,1,0,0,0,780,781,1,0,0,0,781,782,1,0,0,0,782,784,3,198,99,
        0,783,785,5,131,0,0,784,783,1,0,0,0,784,785,1,0,0,0,785,787,1,0,
        0,0,786,788,3,84,42,0,787,786,1,0,0,0,787,788,1,0,0,0,788,790,1,
        0,0,0,789,791,5,131,0,0,790,789,1,0,0,0,790,791,1,0,0,0,791,792,
        1,0,0,0,792,793,3,198,99,0,793,823,1,0,0,0,794,796,3,198,99,0,795,
        797,5,131,0,0,796,795,1,0,0,0,796,797,1,0,0,0,797,799,1,0,0,0,798,
        800,3,84,42,0,799,798,1,0,0,0,799,800,1,0,0,0,800,802,1,0,0,0,801,
        803,5,131,0,0,802,801,1,0,0,0,802,803,1,0,0,0,803,804,1,0,0,0,804,
        806,3,198,99,0,805,807,5,131,0,0,806,805,1,0,0,0,806,807,1,0,0,0,
        807,808,1,0,0,0,808,809,3,196,98,0,809,823,1,0,0,0,810,812,3,198,
        99,0,811,813,5,131,0,0,812,811,1,0,0,0,812,813,1,0,0,0,813,815,1,
        0,0,0,814,816,3,84,42,0,815,814,1,0,0,0,815,816,1,0,0,0,816,818,
        1,0,0,0,817,819,5,131,0,0,818,817,1,0,0,0,818,819,1,0,0,0,819,820,
        1,0,0,0,820,821,3,198,99,0,821,823,1,0,0,0,822,758,1,0,0,0,822,778,
        1,0,0,0,822,794,1,0,0,0,822,810,1,0,0,0,823,83,1,0,0,0,824,826,5,
        8,0,0,825,827,5,131,0,0,826,825,1,0,0,0,826,827,1,0,0,0,827,832,
        1,0,0,0,828,830,3,172,86,0,829,831,5,131,0,0,830,829,1,0,0,0,830,
        831,1,0,0,0,831,833,1,0,0,0,832,828,1,0,0,0,832,833,1,0,0,0,833,
        838,1,0,0,0,834,836,3,88,44,0,835,837,5,131,0,0,836,835,1,0,0,0,
        836,837,1,0,0,0,837,839,1,0,0,0,838,834,1,0,0,0,838,839,1,0,0,0,
        839,841,1,0,0,0,840,842,3,94,47,0,841,840,1,0,0,0,841,842,1,0,0,
        0,842,847,1,0,0,0,843,845,3,86,43,0,844,846,5,131,0,0,845,844,1,
        0,0,0,845,846,1,0,0,0,846,848,1,0,0,0,847,843,1,0,0,0,847,848,1,
        0,0,0,848,849,1,0,0,0,849,850,5,9,0,0,850,85,1,0,0,0,851,854,3,176,
        88,0,852,854,3,178,89,0,853,851,1,0,0,0,853,852,1,0,0,0,854,87,1,
        0,0,0,855,857,5,10,0,0,856,858,5,131,0,0,857,856,1,0,0,0,857,858,
        1,0,0,0,858,859,1,0,0,0,859,873,3,98,49,0,860,862,5,131,0,0,861,
        860,1,0,0,0,861,862,1,0,0,0,862,863,1,0,0,0,863,865,5,11,0,0,864,
        866,5,10,0,0,865,864,1,0,0,0,865,866,1,0,0,0,866,868,1,0,0,0,867,
        869,5,131,0,0,868,867,1,0,0,0,868,869,1,0,0,0,869,870,1,0,0,0,870,
        872,3,98,49,0,871,861,1,0,0,0,872,875,1,0,0,0,873,871,1,0,0,0,873,
        874,1,0,0,0,874,89,1,0,0,0,875,873,1,0,0,0,876,883,3,92,46,0,877,
        879,5,131,0,0,878,877,1,0,0,0,878,879,1,0,0,0,879,880,1,0,0,0,880,
        882,3,92,46,0,881,878,1,0,0,0,882,885,1,0,0,0,883,881,1,0,0,0,883,
        884,1,0,0,0,884,91,1,0,0,0,885,883,1,0,0,0,886,888,5,10,0,0,887,
        889,5,131,0,0,888,887,1,0,0,0,888,889,1,0,0,0,889,890,1,0,0,0,890,
        891,3,96,48,0,891,93,1,0,0,0,892,894,5,5,0,0,893,895,5,131,0,0,894,
        893,1,0,0,0,894,895,1,0,0,0,895,900,1,0,0,0,896,898,3,184,92,0,897,
        899,5,131,0,0,898,897,1,0,0,0,898,899,1,0,0,0,899,901,1,0,0,0,900,
        896,1,0,0,0,900,901,1,0,0,0,901,912,1,0,0,0,902,904,5,12,0,0,903,
        905,5,131,0,0,904,903,1,0,0,0,904,905,1,0,0,0,905,910,1,0,0,0,906,
        908,3,184,92,0,907,909,5,131,0,0,908,907,1,0,0,0,908,909,1,0,0,0,
        909,911,1,0,0,0,910,906,1,0,0,0,910,911,1,0,0,0,911,913,1,0,0,0,
        912,902,1,0,0,0,912,913,1,0,0,0,913,95,1,0,0,0,914,915,3,188,94,
        0,915,97,1,0,0,0,916,917,3,188,94,0,917,99,1,0,0,0,918,919,3,102,
        51,0,919,101,1,0,0,0,920,927,3,104,52,0,921,922,5,131,0,0,922,923,
        5,78,0,0,923,924,5,131,0,0,924,926,3,104,52,0,925,921,1,0,0,0,926,
        929,1,0,0,0,927,925,1,0,0,0,927,928,1,0,0,0,928,103,1,0,0,0,929,
        927,1,0,0,0,930,937,3,106,53,0,931,932,5,131,0,0,932,933,5,79,0,
        0,933,934,5,131,0,0,934,936,3,106,53,0,935,931,1,0,0,0,936,939,1,
        0,0,0,937,935,1,0,0,0,937,938,1,0,0,0,938,105,1,0,0,0,939,937,1,
        0,0,0,940,947,3,108,54,0,941,942,5,131,0,0,942,943,5,80,0,0,943,
        944,5,131,0,0,944,946,3,108,54,0,945,941,1,0,0,0,946,949,1,0,0,0,
        947,945,1,0,0,0,947,948,1,0,0,0,948,107,1,0,0,0,949,947,1,0,0,0,
        950,952,5,81,0,0,951,953,5,131,0,0,952,951,1,0,0,0,952,953,1,0,0,
        0,953,955,1,0,0,0,954,950,1,0,0,0,955,958,1,0,0,0,956,954,1,0,0,
        0,956,957,1,0,0,0,957,959,1,0,0,0,958,956,1,0,0,0,959,960,3,110,
        55,0,960,109,1,0,0,0,961,968,3,112,56,0,962,964,5,131,0,0,963,962,
        1,0,0,0,963,964,1,0,0,0,964,965,1,0,0,0,965,967,3,138,69,0,966,963,
        1,0,0,0,967,970,1,0,0,0,968,966,1,0,0,0,968,969,1,0,0,0,969,111,
        1,0,0,0,970,968,1,0,0,0,971,990,3,114,57,0,972,974,5,131,0,0,973,
        972,1,0,0,0,973,974,1,0,0,0,974,975,1,0,0,0,975,977,5,13,0,0,976,
        978,5,131,0,0,977,976,1,0,0,0,977,978,1,0,0,0,978,979,1,0,0,0,979,
        989,3,114,57,0,980,982,5,131,0,0,981,980,1,0,0,0,981,982,1,0,0,0,
        982,983,1,0,0,0,983,985,5,14,0,0,984,986,5,131,0,0,985,984,1,0,0,
        0,985,986,1,0,0,0,986,987,1,0,0,0,987,989,3,114,57,0,988,973,1,0,
        0,0,988,981,1,0,0,0,989,992,1,0,0,0,990,988,1,0,0,0,990,991,1,0,
        0,0,991,113,1,0,0,0,992,990,1,0,0,0,993,1020,3,116,58,0,994,996,
        5,131,0,0,995,994,1,0,0,0,995,996,1,0,0,0,996,997,1,0,0,0,997,999,
        5,5,0,0,998,1000,5,131,0,0,999,998,1,0,0,0,999,1000,1,0,0,0,1000,
        1001,1,0,0,0,1001,1019,3,116,58,0,1002,1004,5,131,0,0,1003,1002,
        1,0,0,0,1003,1004,1,0,0,0,1004,1005,1,0,0,0,1005,1007,5,15,0,0,1006,
        1008,5,131,0,0,1007,1006,1,0,0,0,1007,1008,1,0,0,0,1008,1009,1,0,
        0,0,1009,1019,3,116,58,0,1010,1012,5,131,0,0,1011,1010,1,0,0,0,1011,
        1012,1,0,0,0,1012,1013,1,0,0,0,1013,1015,5,16,0,0,1014,1016,5,131,
        0,0,1015,1014,1,0,0,0,1015,1016,1,0,0,0,1016,1017,1,0,0,0,1017,1019,
        3,116,58,0,1018,995,1,0,0,0,1018,1003,1,0,0,0,1018,1011,1,0,0,0,
        1019,1022,1,0,0,0,1020,1018,1,0,0,0,1020,1021,1,0,0,0,1021,115,1,
        0,0,0,1022,1020,1,0,0,0,1023,1034,3,118,59,0,1024,1026,5,131,0,0,
        1025,1024,1,0,0,0,1025,1026,1,0,0,0,1026,1027,1,0,0,0,1027,1029,
        5,17,0,0,1028,1030,5,131,0,0,1029,1028,1,0,0,0,1029,1030,1,0,0,0,
        1030,1031,1,0,0,0,1031,1033,3,118,59,0,1032,1025,1,0,0,0,1033,1036,
        1,0,0,0,1034,1032,1,0,0,0,1034,1035,1,0,0,0,1035,117,1,0,0,0,1036,
        1034,1,0,0,0,1037,1039,7,1,0,0,1038,1040,5,131,0,0,1039,1038,1,0,
        0,0,1039,1040,1,0,0,0,1040,1042,1,0,0,0,1041,1037,1,0,0,0,1042,1045,
        1,0,0,0,1043,1041,1,0,0,0,1043,1044,1,0,0,0,1044,1046,1,0,0,0,1045,
        1043,1,0,0,0,1046,1047,3,120,60,0,1047,119,1,0,0,0,1048,1054,3,128,
        64,0,1049,1053,3,124,62,0,1050,1053,3,122,61,0,1051,1053,3,126,63,
        0,1052,1049,1,0,0,0,1052,1050,1,0,0,0,1052,1051,1,0,0,0,1053,1056,
        1,0,0,0,1054,1052,1,0,0,0,1054,1055,1,0,0,0,1055,121,1,0,0,0,1056,
        1054,1,0,0,0,1057,1058,5,131,0,0,1058,1060,5,82,0,0,1059,1061,5,
        131,0,0,1060,1059,1,0,0,0,1060,1061,1,0,0,0,1061,1062,1,0,0,0,1062,
        1083,3,128,64,0,1063,1065,5,131,0,0,1064,1063,1,0,0,0,1064,1065,
        1,0,0,0,1065,1066,1,0,0,0,1066,1067,5,8,0,0,1067,1068,3,100,50,0,
        1068,1069,5,9,0,0,1069,1083,1,0,0,0,1070,1072,5,131,0,0,1071,1070,
        1,0,0,0,1071,1072,1,0,0,0,1072,1073,1,0,0,0,1073,1075,5,8,0,0,1074,
        1076,3,100,50,0,1075,1074,1,0,0,0,1075,1076,1,0,0,0,1076,1077,1,
        0,0,0,1077,1079,5,12,0,0,1078,1080,3,100,50,0,1079,1078,1,0,0,0,
        1079,1080,1,0,0,0,1080,1081,1,0,0,0,1081,1083,5,9,0,0,1082,1057,
        1,0,0,0,1082,1064,1,0,0,0,1082,1071,1,0,0,0,1083,123,1,0,0,0,1084,
        1085,5,131,0,0,1085,1086,5,83,0,0,1086,1087,5,131,0,0,1087,1097,
        5,63,0,0,1088,1089,5,131,0,0,1089,1090,5,84,0,0,1090,1091,5,131,
        0,0,1091,1097,5,63,0,0,1092,1093,5,131,0,0,1093,1097,5,85,0,0,1094,
        1095,5,131,0,0,1095,1097,5,86,0,0,1096,1084,1,0,0,0,1096,1088,1,
        0,0,0,1096,1092,1,0,0,0,1096,1094,1,0,0,0,1097,1099,1,0,0,0,1098,
        1100,5,131,0,0,1099,1098,1,0,0,0,1099,1100,1,0,0,0,1100,1101,1,0,
        0,0,1101,1102,3,128,64,0,1102,125,1,0,0,0,1103,1104,5,131,0,0,1104,
        1105,5,87,0,0,1105,1106,5,131,0,0,1106,1114,5,88,0,0,1107,1108,5,
        131,0,0,1108,1109,5,87,0,0,1109,1110,5,131,0,0,1110,1111,5,81,0,
        0,1111,1112,5,131,0,0,1112,1114,5,88,0,0,1113,1103,1,0,0,0,1113,
        1107,1,0,0,0,1114,127,1,0,0,0,1115,1122,3,130,65,0,1116,1118,5,131,
        0,0,1117,1116,1,0,0,0,1117,1118,1,0,0,0,1118,1119,1,0,0,0,1119,1121,
        3,166,83,0,1120,1117,1,0,0,0,1121,1124,1,0,0,0,1122,1120,1,0,0,0,
        1122,1123,1,0,0,0,1123,1129,1,0,0,0,1124,1122,1,0,0,0,1125,1127,
        5,131,0,0,1126,1125,1,0,0,0,1126,1127,1,0,0,0,1127,1128,1,0,0,0,
        1128,1130,3,90,45,0,1129,1126,1,0,0,0,1129,1130,1,0,0,0,1130,129,
        1,0,0,0,1131,1210,3,132,66,0,1132,1210,3,178,89,0,1133,1210,3,168,
        84,0,1134,1136,5,89,0,0,1135,1137,5,131,0,0,1136,1135,1,0,0,0,1136,
        1137,1,0,0,0,1137,1138,1,0,0,0,1138,1140,5,6,0,0,1139,1141,5,131,
        0,0,1140,1139,1,0,0,0,1140,1141,1,0,0,0,1141,1142,1,0,0,0,1142,1144,
        5,5,0,0,1143,1145,5,131,0,0,1144,1143,1,0,0,0,1144,1145,1,0,0,0,
        1145,1146,1,0,0,0,1146,1210,5,7,0,0,1147,1210,3,162,81,0,1148,1210,
        3,164,82,0,1149,1151,5,49,0,0,1150,1152,5,131,0,0,1151,1150,1,0,
        0,0,1151,1152,1,0,0,0,1152,1153,1,0,0,0,1153,1155,5,6,0,0,1154,1156,
        5,131,0,0,1155,1154,1,0,0,0,1155,1156,1,0,0,0,1156,1157,1,0,0,0,
        1157,1159,3,144,72,0,1158,1160,5,131,0,0,1159,1158,1,0,0,0,1159,
        1160,1,0,0,0,1160,1161,1,0,0,0,1161,1162,5,7,0,0,1162,1210,1,0,0,
        0,1163,1165,5,90,0,0,1164,1166,5,131,0,0,1165,1164,1,0,0,0,1165,
        1166,1,0,0,0,1166,1167,1,0,0,0,1167,1169,5,6,0,0,1168,1170,5,131,
        0,0,1169,1168,1,0,0,0,1169,1170,1,0,0,0,1170,1171,1,0,0,0,1171,1173,
        3,144,72,0,1172,1174,5,131,0,0,1173,1172,1,0,0,0,1173,1174,1,0,0,
        0,1174,1175,1,0,0,0,1175,1176,5,7,0,0,1176,1210,1,0,0,0,1177,1179,
        5,91,0,0,1178,1180,5,131,0,0,1179,1178,1,0,0,0,1179,1180,1,0,0,0,
        1180,1181,1,0,0,0,1181,1183,5,6,0,0,1182,1184,5,131,0,0,1183,1182,
        1,0,0,0,1183,1184,1,0,0,0,1184,1185,1,0,0,0,1185,1187,3,144,72,0,
        1186,1188,5,131,0,0,1187,1186,1,0,0,0,1187,1188,1,0,0,0,1188,1189,
        1,0,0,0,1189,1190,5,7,0,0,1190,1210,1,0,0,0,1191,1193,5,92,0,0,1192,
        1194,5,131,0,0,1193,1192,1,0,0,0,1193,1194,1,0,0,0,1194,1195,1,0,
        0,0,1195,1197,5,6,0,0,1196,1198,5,131,0,0,1197,1196,1,0,0,0,1197,
        1198,1,0,0,0,1198,1199,1,0,0,0,1199,1201,3,144,72,0,1200,1202,5,
        131,0,0,1201,1200,1,0,0,0,1201,1202,1,0,0,0,1202,1203,1,0,0,0,1203,
        1204,5,7,0,0,1204,1210,1,0,0,0,1205,1210,3,142,71,0,1206,1210,3,
        140,70,0,1207,1210,3,148,74,0,1208,1210,3,172,86,0,1209,1131,1,0,
        0,0,1209,1132,1,0,0,0,1209,1133,1,0,0,0,1209,1134,1,0,0,0,1209,1147,
        1,0,0,0,1209,1148,1,0,0,0,1209,1149,1,0,0,0,1209,1163,1,0,0,0,1209,
        1177,1,0,0,0,1209,1191,1,0,0,0,1209,1205,1,0,0,0,1209,1206,1,0,0,
        0,1209,1207,1,0,0,0,1209,1208,1,0,0,0,1210,131,1,0,0,0,1211,1218,
        3,174,87,0,1212,1218,5,101,0,0,1213,1218,3,134,67,0,1214,1218,5,
        88,0,0,1215,1218,3,176,88,0,1216,1218,3,136,68,0,1217,1211,1,0,0,
        0,1217,1212,1,0,0,0,1217,1213,1,0,0,0,1217,1214,1,0,0,0,1217,1215,
        1,0,0,0,1217,1216,1,0,0,0,1218,133,1,0,0,0,1219,1220,7,2,0,0,1220,
        135,1,0,0,0,1221,1223,5,8,0,0,1222,1224,5,131,0,0,1223,1222,1,0,
        0,0,1223,1224,1,0,0,0,1224,1242,1,0,0,0,1225,1227,3,100,50,0,1226,
        1228,5,131,0,0,1227,1226,1,0,0,0,1227,1228,1,0,0,0,1228,1239,1,0,
        0,0,1229,1231,5,2,0,0,1230,1232,5,131,0,0,1231,1230,1,0,0,0,1231,
        1232,1,0,0,0,1232,1233,1,0,0,0,1233,1235,3,100,50,0,1234,1236,5,
        131,0,0,1235,1234,1,0,0,0,1235,1236,1,0,0,0,1236,1238,1,0,0,0,1237,
        1229,1,0,0,0,1238,1241,1,0,0,0,1239,1237,1,0,0,0,1239,1240,1,0,0,
        0,1240,1243,1,0,0,0,1241,1239,1,0,0,0,1242,1225,1,0,0,0,1242,1243,
        1,0,0,0,1243,1244,1,0,0,0,1244,1245,5,9,0,0,1245,137,1,0,0,0,1246,
        1248,5,3,0,0,1247,1249,5,131,0,0,1248,1247,1,0,0,0,1248,1249,1,0,
        0,0,1249,1250,1,0,0,0,1250,1277,3,112,56,0,1251,1253,5,18,0,0,1252,
        1254,5,131,0,0,1253,1252,1,0,0,0,1253,1254,1,0,0,0,1254,1255,1,0,
        0,0,1255,1277,3,112,56,0,1256,1258,5,19,0,0,1257,1259,5,131,0,0,
        1258,1257,1,0,0,0,1258,1259,1,0,0,0,1259,1260,1,0,0,0,1260,1277,
        3,112,56,0,1261,1263,5,20,0,0,1262,1264,5,131,0,0,1263,1262,1,0,
        0,0,1263,1264,1,0,0,0,1264,1265,1,0,0,0,1265,1277,3,112,56,0,1266,
        1268,5,21,0,0,1267,1269,5,131,0,0,1268,1267,1,0,0,0,1268,1269,1,
        0,0,0,1269,1270,1,0,0,0,1270,1277,3,112,56,0,1271,1273,5,22,0,0,
        1272,1274,5,131,0,0,1273,1272,1,0,0,0,1273,1274,1,0,0,0,1274,1275,
        1,0,0,0,1275,1277,3,112,56,0,1276,1246,1,0,0,0,1276,1251,1,0,0,0,
        1276,1256,1,0,0,0,1276,1261,1,0,0,0,1276,1266,1,0,0,0,1276,1271,
        1,0,0,0,1277,139,1,0,0,0,1278,1280,5,6,0,0,1279,1281,5,131,0,0,1280,
        1279,1,0,0,0,1280,1281,1,0,0,0,1281,1282,1,0,0,0,1282,1284,3,100,
        50,0,1283,1285,5,131,0,0,1284,1283,1,0,0,0,1284,1285,1,0,0,0,1285,
        1286,1,0,0,0,1286,1287,5,7,0,0,1287,141,1,0,0,0,1288,1293,3,78,39,
        0,1289,1291,5,131,0,0,1290,1289,1,0,0,0,1290,1291,1,0,0,0,1291,1292,
        1,0,0,0,1292,1294,3,80,40,0,1293,1290,1,0,0,0,1294,1295,1,0,0,0,
        1295,1293,1,0,0,0,1295,1296,1,0,0,0,1296,143,1,0,0,0,1297,1302,3,
        146,73,0,1298,1300,5,131,0,0,1299,1298,1,0,0,0,1299,1300,1,0,0,0,
        1300,1301,1,0,0,0,1301,1303,3,68,34,0,1302,1299,1,0,0,0,1302,1303,
        1,0,0,0,1303,145,1,0,0,0,1304,1305,3,172,86,0,1305,1306,5,131,0,
        0,1306,1307,5,82,0,0,1307,1308,5,131,0,0,1308,1309,3,100,50,0,1309,
        147,1,0,0,0,1310,1312,3,150,75,0,1311,1313,5,131,0,0,1312,1311,1,
        0,0,0,1312,1313,1,0,0,0,1313,1314,1,0,0,0,1314,1316,5,6,0,0,1315,
        1317,5,131,0,0,1316,1315,1,0,0,0,1316,1317,1,0,0,0,1317,1322,1,0,
        0,0,1318,1320,5,64,0,0,1319,1321,5,131,0,0,1320,1319,1,0,0,0,1320,
        1321,1,0,0,0,1321,1323,1,0,0,0,1322,1318,1,0,0,0,1322,1323,1,0,0,
        0,1323,1341,1,0,0,0,1324,1326,3,100,50,0,1325,1327,5,131,0,0,1326,
        1325,1,0,0,0,1326,1327,1,0,0,0,1327,1338,1,0,0,0,1328,1330,5,2,0,
        0,1329,1331,5,131,0,0,1330,1329,1,0,0,0,1330,1331,1,0,0,0,1331,1332,
        1,0,0,0,1332,1334,3,100,50,0,1333,1335,5,131,0,0,1334,1333,1,0,0,
        0,1334,1335,1,0,0,0,1335,1337,1,0,0,0,1336,1328,1,0,0,0,1337,1340,
        1,0,0,0,1338,1336,1,0,0,0,1338,1339,1,0,0,0,1339,1342,1,0,0,0,1340,
        1338,1,0,0,0,1341,1324,1,0,0,0,1341,1342,1,0,0,0,1342,1343,1,0,0,
        0,1343,1344,5,7,0,0,1344,149,1,0,0,0,1345,1346,3,160,80,0,1346,1347,
        3,190,95,0,1347,1350,1,0,0,0,1348,1350,5,95,0,0,1349,1345,1,0,0,
        0,1349,1348,1,0,0,0,1350,151,1,0,0,0,1351,1353,3,158,79,0,1352,1354,
        5,131,0,0,1353,1352,1,0,0,0,1353,1354,1,0,0,0,1354,1355,1,0,0,0,
        1355,1357,5,6,0,0,1356,1358,5,131,0,0,1357,1356,1,0,0,0,1357,1358,
        1,0,0,0,1358,1376,1,0,0,0,1359,1361,3,100,50,0,1360,1362,5,131,0,
        0,1361,1360,1,0,0,0,1361,1362,1,0,0,0,1362,1373,1,0,0,0,1363,1365,
        5,2,0,0,1364,1366,5,131,0,0,1365,1364,1,0,0,0,1365,1366,1,0,0,0,
        1366,1367,1,0,0,0,1367,1369,3,100,50,0,1368,1370,5,131,0,0,1369,
        1368,1,0,0,0,1369,1370,1,0,0,0,1370,1372,1,0,0,0,1371,1363,1,0,0,
        0,1372,1375,1,0,0,0,1373,1371,1,0,0,0,1373,1374,1,0,0,0,1374,1377,
        1,0,0,0,1375,1373,1,0,0,0,1376,1359,1,0,0,0,1376,1377,1,0,0,0,1377,
        1378,1,0,0,0,1378,1379,5,7,0,0,1379,153,1,0,0,0,1380,1381,3,158,
        79,0,1381,155,1,0,0,0,1382,1383,3,190,95,0,1383,157,1,0,0,0,1384,
        1385,3,160,80,0,1385,1386,3,190,95,0,1386,159,1,0,0,0,1387,1388,
        3,190,95,0,1388,1389,5,23,0,0,1389,1391,1,0,0,0,1390,1387,1,0,0,
        0,1391,1394,1,0,0,0,1392,1390,1,0,0,0,1392,1393,1,0,0,0,1393,161,
        1,0,0,0,1394,1392,1,0,0,0,1395,1397,5,8,0,0,1396,1398,5,131,0,0,
        1397,1396,1,0,0,0,1397,1398,1,0,0,0,1398,1399,1,0,0,0,1399,1408,
        3,144,72,0,1400,1402,5,131,0,0,1401,1400,1,0,0,0,1401,1402,1,0,0,
        0,1402,1403,1,0,0,0,1403,1405,5,11,0,0,1404,1406,5,131,0,0,1405,
        1404,1,0,0,0,1405,1406,1,0,0,0,1406,1407,1,0,0,0,1407,1409,3,100,
        50,0,1408,1401,1,0,0,0,1408,1409,1,0,0,0,1409,1411,1,0,0,0,1410,
        1412,5,131,0,0,1411,1410,1,0,0,0,1411,1412,1,0,0,0,1412,1413,1,0,
        0,0,1413,1414,5,9,0,0,1414,163,1,0,0,0,1415,1417,5,8,0,0,1416,1418,
        5,131,0,0,1417,1416,1,0,0,0,1417,1418,1,0,0,0,1418,1427,1,0,0,0,
        1419,1421,3,172,86,0,1420,1422,5,131,0,0,1421,1420,1,0,0,0,1421,
        1422,1,0,0,0,1422,1423,1,0,0,0,1423,1425,5,3,0,0,1424,1426,5,131,
        0,0,1425,1424,1,0,0,0,1425,1426,1,0,0,0,1426,1428,1,0,0,0,1427,1419,
        1,0,0,0,1427,1428,1,0,0,0,1428,1429,1,0,0,0,1429,1431,3,142,71,0,
        1430,1432,5,131,0,0,1431,1430,1,0,0,0,1431,1432,1,0,0,0,1432,1441,
        1,0,0,0,1433,1435,5,77,0,0,1434,1436,5,131,0,0,1435,1434,1,0,0,0,
        1435,1436,1,0,0,0,1436,1437,1,0,0,0,1437,1439,3,100,50,0,1438,1440,
        5,131,0,0,1439,1438,1,0,0,0,1439,1440,1,0,0,0,1440,1442,1,0,0,0,
        1441,1433,1,0,0,0,1441,1442,1,0,0,0,1442,1443,1,0,0,0,1443,1445,
        5,11,0,0,1444,1446,5,131,0,0,1445,1444,1,0,0,0,1445,1446,1,0,0,0,
        1446,1447,1,0,0,0,1447,1449,3,100,50,0,1448,1450,5,131,0,0,1449,
        1448,1,0,0,0,1449,1450,1,0,0,0,1450,1451,1,0,0,0,1451,1452,5,9,0,
        0,1452,165,1,0,0,0,1453,1455,5,23,0,0,1454,1456,5,131,0,0,1455,1454,
        1,0,0,0,1455,1456,1,0,0,0,1456,1457,1,0,0,0,1457,1458,3,182,91,0,
        1458,167,1,0,0,0,1459,1464,5,96,0,0,1460,1462,5,131,0,0,1461,1460,
        1,0,0,0,1461,1462,1,0,0,0,1462,1463,1,0,0,0,1463,1465,3,170,85,0,
        1464,1461,1,0,0,0,1465,1466,1,0,0,0,1466,1464,1,0,0,0,1466,1467,
        1,0,0,0,1467,1482,1,0,0,0,1468,1470,5,96,0,0,1469,1471,5,131,0,0,
        1470,1469,1,0,0,0,1470,1471,1,0,0,0,1471,1472,1,0,0,0,1472,1477,
        3,100,50,0,1473,1475,5,131,0,0,1474,1473,1,0,0,0,1474,1475,1,0,0,
        0,1475,1476,1,0,0,0,1476,1478,3,170,85,0,1477,1474,1,0,0,0,1478,
        1479,1,0,0,0,1479,1477,1,0,0,0,1479,1480,1,0,0,0,1480,1482,1,0,0,
        0,1481,1459,1,0,0,0,1481,1468,1,0,0,0,1482,1491,1,0,0,0,1483,1485,
        5,131,0,0,1484,1483,1,0,0,0,1484,1485,1,0,0,0,1485,1486,1,0,0,0,
        1486,1488,5,97,0,0,1487,1489,5,131,0,0,1488,1487,1,0,0,0,1488,1489,
        1,0,0,0,1489,1490,1,0,0,0,1490,1492,3,100,50,0,1491,1484,1,0,0,0,
        1491,1492,1,0,0,0,1492,1494,1,0,0,0,1493,1495,5,131,0,0,1494,1493,
        1,0,0,0,1494,1495,1,0,0,0,1495,1496,1,0,0,0,1496,1497,5,98,0,0,1497,
        169,1,0,0,0,1498,1500,5,99,0,0,1499,1501,5,131,0,0,1500,1499,1,0,
        0,0,1500,1501,1,0,0,0,1501,1502,1,0,0,0,1502,1504,3,100,50,0,1503,
        1505,5,131,0,0,1504,1503,1,0,0,0,1504,1505,1,0,0,0,1505,1506,1,0,
        0,0,1506,1508,5,100,0,0,1507,1509,5,131,0,0,1508,1507,1,0,0,0,1508,
        1509,1,0,0,0,1509,1510,1,0,0,0,1510,1511,3,100,50,0,1511,171,1,0,
        0,0,1512,1513,3,190,95,0,1513,173,1,0,0,0,1514,1517,3,186,93,0,1515,
        1517,3,184,92,0,1516,1514,1,0,0,0,1516,1515,1,0,0,0,1517,175,1,0,
        0,0,1518,1520,5,24,0,0,1519,1521,5,131,0,0,1520,1519,1,0,0,0,1520,
        1521,1,0,0,0,1521,1555,1,0,0,0,1522,1524,3,182,91,0,1523,1525,5,
        131,0,0,1524,1523,1,0,0,0,1524,1525,1,0,0,0,1525,1526,1,0,0,0,1526,
        1528,5,10,0,0,1527,1529,5,131,0,0,1528,1527,1,0,0,0,1528,1529,1,
        0,0,0,1529,1530,1,0,0,0,1530,1532,3,100,50,0,1531,1533,5,131,0,0,
        1532,1531,1,0,0,0,1532,1533,1,0,0,0,1533,1552,1,0,0,0,1534,1536,
        5,2,0,0,1535,1537,5,131,0,0,1536,1535,1,0,0,0,1536,1537,1,0,0,0,
        1537,1538,1,0,0,0,1538,1540,3,182,91,0,1539,1541,5,131,0,0,1540,
        1539,1,0,0,0,1540,1541,1,0,0,0,1541,1542,1,0,0,0,1542,1544,5,10,
        0,0,1543,1545,5,131,0,0,1544,1543,1,0,0,0,1544,1545,1,0,0,0,1545,
        1546,1,0,0,0,1546,1548,3,100,50,0,1547,1549,5,131,0,0,1548,1547,
        1,0,0,0,1548,1549,1,0,0,0,1549,1551,1,0,0,0,1550,1534,1,0,0,0,1551,
        1554,1,0,0,0,1552,1550,1,0,0,0,1552,1553,1,0,0,0,1553,1556,1,0,0,
        0,1554,1552,1,0,0,0,1555,1522,1,0,0,0,1555,1556,1,0,0,0,1556,1557,
        1,0,0,0,1557,1558,5,25,0,0,1558,177,1,0,0,0,1559,1562,5,26,0,0,1560,
        1563,3,190,95,0,1561,1563,5,104,0,0,1562,1560,1,0,0,0,1562,1561,
        1,0,0,0,1563,179,1,0,0,0,1564,1569,3,130,65,0,1565,1567,5,131,0,
        0,1566,1565,1,0,0,0,1566,1567,1,0,0,0,1567,1568,1,0,0,0,1568,1570,
        3,166,83,0,1569,1566,1,0,0,0,1570,1571,1,0,0,0,1571,1569,1,0,0,0,
        1571,1572,1,0,0,0,1572,181,1,0,0,0,1573,1574,3,188,94,0,1574,183,
        1,0,0,0,1575,1576,7,3,0,0,1576,185,1,0,0,0,1577,1578,7,4,0,0,1578,
        187,1,0,0,0,1579,1582,3,190,95,0,1580,1582,3,192,96,0,1581,1579,
        1,0,0,0,1581,1580,1,0,0,0,1582,189,1,0,0,0,1583,1584,7,5,0,0,1584,
        191,1,0,0,0,1585,1586,7,6,0,0,1586,193,1,0,0,0,1587,1588,7,7,0,0,
        1588,195,1,0,0,0,1589,1590,7,8,0,0,1590,197,1,0,0,0,1591,1592,7,
        9,0,0,1592,199,1,0,0,0,293,201,205,208,211,218,223,226,230,234,239,
        246,251,254,258,262,266,272,276,281,286,290,293,295,299,303,308,
        312,317,321,330,335,339,343,347,352,356,359,363,373,380,393,397,
        403,407,411,416,421,425,431,435,441,445,451,455,459,463,467,471,
        476,483,487,492,499,505,510,516,522,527,531,536,539,542,545,552,
        558,561,566,569,573,576,584,588,592,596,600,605,610,614,619,622,
        631,640,645,658,661,677,685,689,694,699,703,708,714,719,726,730,
        734,736,740,742,746,748,754,760,764,767,770,774,780,784,787,790,
        796,799,802,806,812,815,818,822,826,830,832,836,838,841,845,847,
        853,857,861,865,868,873,878,883,888,894,898,900,904,908,910,912,
        927,937,947,952,956,963,968,973,977,981,985,988,990,995,999,1003,
        1007,1011,1015,1018,1020,1025,1029,1034,1039,1043,1052,1054,1060,
        1064,1071,1075,1079,1082,1096,1099,1113,1117,1122,1126,1129,1136,
        1140,1144,1151,1155,1159,1165,1169,1173,1179,1183,1187,1193,1197,
        1201,1209,1217,1223,1227,1231,1235,1239,1242,1248,1253,1258,1263,
        1268,1273,1276,1280,1284,1290,1295,1299,1302,1312,1316,1320,1322,
        1326,1330,1334,1338,1341,1349,1353,1357,1361,1365,1369,1373,1376,
        1392,1397,1401,1405,1408,1411,1417,1421,1425,1427,1431,1435,1439,
        1441,1445,1449,1455,1461,1466,1470,1474,1479,1481,1484,1488,1491,
        1494,1500,1504,1508,1516,1520,1524,1528,1532,1536,1540,1544,1548,
        1552,1555,1562,1566,1571,1581
    ]

class LcypherParser ( Parser ):

    grammarFileName = "Lcypher.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "';'", "','", "'='", "'+='", "'*'", "'('", 
                     "')'", "'['", "']'", "':'", "'|'", "'..'", "'+'", "'-'", 
                     "'/'", "'%'", "'^'", "'<>'", "'<'", "'>'", "'<='", 
                     "'>='", "'.'", "'{'", "'}'", "'$'", "'\\u27E8'", "'\\u3008'", 
                     "'\\uFE64'", "'\\uFF1C'", "'\\u27E9'", "'\\u3009'", 
                     "'\\uFE65'", "'\\uFF1E'", "'\\u00AD'", "'\\u2010'", 
                     "'\\u2011'", "'\\u2012'", "'\\u2013'", "'\\u2014'", 
                     "'\\u2015'", "'\\u2212'", "'\\uFE58'", "'\\uFE63'", 
                     "'\\uFF0D'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'0'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "EXPLAIN", "PROFILE", "UNION", 
                      "ALL", "OPTIONAL_", "MATCH", "UNWIND", "AS", "MERGE", 
                      "ON", "CREATE", "SET", "DETACH", "DELETE_", "REMOVE", 
                      "CALL", "YIELD", "WITH", "DISTINCT", "RETURN", "ORDER", 
                      "BY", "L_SKIP", "LIMIT", "ASCENDING", "ASC", "DESCENDING", 
                      "DESC", "USING", "JOIN", "START", "WHERE", "OR", "XOR", 
                      "AND", "NOT", "IN", "STARTS", "ENDS", "CONTAINS", 
                      "REGEXP", "IS", "NULL_", "COUNT", "ANY", "NONE", "SINGLE", 
                      "TRUE_", "FALSE_", "EXISTS", "CASE", "ELSE", "END", 
                      "WHEN", "THEN", "StringLiteral", "EscapedChar", "HexInteger", 
                      "DecimalInteger", "OctalInteger", "HexLetter", "HexDigit", 
                      "Digit", "NonZeroDigit", "NonZeroOctDigit", "OctDigit", 
                      "ZeroDigit", "ExponentDecimalReal", "RegularDecimalReal", 
                      "FILTER", "EXTRACT", "UnescapedSymbolicName", "CONSTRAINT", 
                      "DO", "FOR", "REQUIRE", "UNIQUE", "MANDATORY", "SCALAR", 
                      "OF", "ADD", "DROP", "IdentifierStart", "IdentifierPart", 
                      "EscapedSymbolicName", "SP", "WHITESPACE", "Comment" ]

    RULE_oC_Cypher = 0
    RULE_oC_Statement = 1
    RULE_oC_Query = 2
    RULE_oC_RegularQuery = 3
    RULE_oC_Union = 4
    RULE_oC_SingleQuery = 5
    RULE_oC_SinglePartQuery = 6
    RULE_oC_MultiPartQuery = 7
    RULE_oC_UpdatingClause = 8
    RULE_oC_ReadingClause = 9
    RULE_oC_Match = 10
    RULE_oC_Unwind = 11
    RULE_oC_Merge = 12
    RULE_oC_MergeAction = 13
    RULE_oC_Create = 14
    RULE_oC_Set = 15
    RULE_oC_SetItem = 16
    RULE_oC_Delete = 17
    RULE_oC_Remove = 18
    RULE_oC_RemoveItem = 19
    RULE_oC_InQueryCall = 20
    RULE_oC_StandaloneCall = 21
    RULE_oC_YieldItems = 22
    RULE_oC_YieldItem = 23
    RULE_oC_With = 24
    RULE_oC_Return = 25
    RULE_oC_ReturnBody = 26
    RULE_oC_ReturnItems = 27
    RULE_oC_ReturnItem = 28
    RULE_oC_Order = 29
    RULE_oC_Skip = 30
    RULE_oC_Limit = 31
    RULE_oC_SortItem = 32
    RULE_oC_Hint = 33
    RULE_oC_Where = 34
    RULE_oC_Pattern = 35
    RULE_oC_PatternPart = 36
    RULE_oC_AnonymousPatternPart = 37
    RULE_oC_PatternElement = 38
    RULE_oC_NodePattern = 39
    RULE_oC_PatternElementChain = 40
    RULE_oC_RelationshipPattern = 41
    RULE_oC_RelationshipDetail = 42
    RULE_oC_Properties = 43
    RULE_oC_RelationshipTypes = 44
    RULE_oC_NodeLabels = 45
    RULE_oC_NodeLabel = 46
    RULE_oC_RangeLiteral = 47
    RULE_oC_LabelName = 48
    RULE_oC_RelTypeName = 49
    RULE_oC_Expression = 50
    RULE_oC_OrExpression = 51
    RULE_oC_XorExpression = 52
    RULE_oC_AndExpression = 53
    RULE_oC_NotExpression = 54
    RULE_oC_ComparisonExpression = 55
    RULE_oC_AddOrSubtractExpression = 56
    RULE_oC_MultiplyDivideModuloExpression = 57
    RULE_oC_PowerOfExpression = 58
    RULE_oC_UnaryAddOrSubtractExpression = 59
    RULE_oC_StringListNullOperatorExpression = 60
    RULE_oC_ListOperatorExpression = 61
    RULE_oC_StringOperatorExpression = 62
    RULE_oC_NullOperatorExpression = 63
    RULE_oC_PropertyOrLabelsExpression = 64
    RULE_oC_Atom = 65
    RULE_oC_Literal = 66
    RULE_oC_BooleanLiteral = 67
    RULE_oC_ListLiteral = 68
    RULE_oC_PartialComparisonExpression = 69
    RULE_oC_ParenthesizedExpression = 70
    RULE_oC_RelationshipsPattern = 71
    RULE_oC_FilterExpression = 72
    RULE_oC_IdInColl = 73
    RULE_oC_FunctionInvocation = 74
    RULE_oC_FunctionName = 75
    RULE_oC_ExplicitProcedureInvocation = 76
    RULE_oC_ImplicitProcedureInvocation = 77
    RULE_oC_ProcedureResultField = 78
    RULE_oC_ProcedureName = 79
    RULE_oC_Namespace = 80
    RULE_oC_ListComprehension = 81
    RULE_oC_PatternComprehension = 82
    RULE_oC_PropertyLookup = 83
    RULE_oC_CaseExpression = 84
    RULE_oC_CaseAlternatives = 85
    RULE_oC_Variable = 86
    RULE_oC_NumberLiteral = 87
    RULE_oC_MapLiteral = 88
    RULE_oC_Parameter = 89
    RULE_oC_PropertyExpression = 90
    RULE_oC_PropertyKeyName = 91
    RULE_oC_IntegerLiteral = 92
    RULE_oC_DoubleLiteral = 93
    RULE_oC_SchemaName = 94
    RULE_oC_SymbolicName = 95
    RULE_oC_ReservedWord = 96
    RULE_oC_LeftArrowHead = 97
    RULE_oC_RightArrowHead = 98
    RULE_oC_Dash = 99

    ruleNames =  [ "oC_Cypher", "oC_Statement", "oC_Query", "oC_RegularQuery", 
                   "oC_Union", "oC_SingleQuery", "oC_SinglePartQuery", "oC_MultiPartQuery", 
                   "oC_UpdatingClause", "oC_ReadingClause", "oC_Match", 
                   "oC_Unwind", "oC_Merge", "oC_MergeAction", "oC_Create", 
                   "oC_Set", "oC_SetItem", "oC_Delete", "oC_Remove", "oC_RemoveItem", 
                   "oC_InQueryCall", "oC_StandaloneCall", "oC_YieldItems", 
                   "oC_YieldItem", "oC_With", "oC_Return", "oC_ReturnBody", 
                   "oC_ReturnItems", "oC_ReturnItem", "oC_Order", "oC_Skip", 
                   "oC_Limit", "oC_SortItem", "oC_Hint", "oC_Where", "oC_Pattern", 
                   "oC_PatternPart", "oC_AnonymousPatternPart", "oC_PatternElement", 
                   "oC_NodePattern", "oC_PatternElementChain", "oC_RelationshipPattern", 
                   "oC_RelationshipDetail", "oC_Properties", "oC_RelationshipTypes", 
                   "oC_NodeLabels", "oC_NodeLabel", "oC_RangeLiteral", "oC_LabelName", 
                   "oC_RelTypeName", "oC_Expression", "oC_OrExpression", 
                   "oC_XorExpression", "oC_AndExpression", "oC_NotExpression", 
                   "oC_ComparisonExpression", "oC_AddOrSubtractExpression", 
                   "oC_MultiplyDivideModuloExpression", "oC_PowerOfExpression", 
                   "oC_UnaryAddOrSubtractExpression", "oC_StringListNullOperatorExpression", 
                   "oC_ListOperatorExpression", "oC_StringOperatorExpression", 
                   "oC_NullOperatorExpression", "oC_PropertyOrLabelsExpression", 
                   "oC_Atom", "oC_Literal", "oC_BooleanLiteral", "oC_ListLiteral", 
                   "oC_PartialComparisonExpression", "oC_ParenthesizedExpression", 
                   "oC_RelationshipsPattern", "oC_FilterExpression", "oC_IdInColl", 
                   "oC_FunctionInvocation", "oC_FunctionName", "oC_ExplicitProcedureInvocation", 
                   "oC_ImplicitProcedureInvocation", "oC_ProcedureResultField", 
                   "oC_ProcedureName", "oC_Namespace", "oC_ListComprehension", 
                   "oC_PatternComprehension", "oC_PropertyLookup", "oC_CaseExpression", 
                   "oC_CaseAlternatives", "oC_Variable", "oC_NumberLiteral", 
                   "oC_MapLiteral", "oC_Parameter", "oC_PropertyExpression", 
                   "oC_PropertyKeyName", "oC_IntegerLiteral", "oC_DoubleLiteral", 
                   "oC_SchemaName", "oC_SymbolicName", "oC_ReservedWord", 
                   "oC_LeftArrowHead", "oC_RightArrowHead", "oC_Dash" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    EXPLAIN=46
    PROFILE=47
    UNION=48
    ALL=49
    OPTIONAL_=50
    MATCH=51
    UNWIND=52
    AS=53
    MERGE=54
    ON=55
    CREATE=56
    SET=57
    DETACH=58
    DELETE_=59
    REMOVE=60
    CALL=61
    YIELD=62
    WITH=63
    DISTINCT=64
    RETURN=65
    ORDER=66
    BY=67
    L_SKIP=68
    LIMIT=69
    ASCENDING=70
    ASC=71
    DESCENDING=72
    DESC=73
    USING=74
    JOIN=75
    START=76
    WHERE=77
    OR=78
    XOR=79
    AND=80
    NOT=81
    IN=82
    STARTS=83
    ENDS=84
    CONTAINS=85
    REGEXP=86
    IS=87
    NULL_=88
    COUNT=89
    ANY=90
    NONE=91
    SINGLE=92
    TRUE_=93
    FALSE_=94
    EXISTS=95
    CASE=96
    ELSE=97
    END=98
    WHEN=99
    THEN=100
    StringLiteral=101
    EscapedChar=102
    HexInteger=103
    DecimalInteger=104
    OctalInteger=105
    HexLetter=106
    HexDigit=107
    Digit=108
    NonZeroDigit=109
    NonZeroOctDigit=110
    OctDigit=111
    ZeroDigit=112
    ExponentDecimalReal=113
    RegularDecimalReal=114
    FILTER=115
    EXTRACT=116
    UnescapedSymbolicName=117
    CONSTRAINT=118
    DO=119
    FOR=120
    REQUIRE=121
    UNIQUE=122
    MANDATORY=123
    SCALAR=124
    OF=125
    ADD=126
    DROP=127
    IdentifierStart=128
    IdentifierPart=129
    EscapedSymbolicName=130
    SP=131
    WHITESPACE=132
    Comment=133

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.13.2")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class OC_CypherContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Statement(self):
            return self.getTypedRuleContext(LcypherParser.OC_StatementContext,0)


        def EOF(self):
            return self.getToken(LcypherParser.EOF, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Cypher

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Cypher" ):
                listener.enterOC_Cypher(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Cypher" ):
                listener.exitOC_Cypher(self)




    def oC_Cypher(self):

        localctx = LcypherParser.OC_CypherContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_oC_Cypher)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 201
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 200
                self.match(LcypherParser.SP)


            self.state = 203
            self.oC_Statement()
            self.state = 208
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.state = 205
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 204
                    self.match(LcypherParser.SP)


                self.state = 207
                self.match(LcypherParser.T__0)


            self.state = 211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 210
                self.match(LcypherParser.SP)


            self.state = 213
            self.match(LcypherParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_StatementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Query(self):
            return self.getTypedRuleContext(LcypherParser.OC_QueryContext,0)


        def EXPLAIN(self):
            return self.getToken(LcypherParser.EXPLAIN, 0)

        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def PROFILE(self):
            return self.getToken(LcypherParser.PROFILE, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Statement" ):
                listener.enterOC_Statement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Statement" ):
                listener.exitOC_Statement(self)




    def oC_Statement(self):

        localctx = LcypherParser.OC_StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_oC_Statement)
        self._la = 0 # Token type
        try:
            self.state = 226
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [50, 51, 52, 54, 56, 57, 58, 59, 60, 61, 63, 65]:
                self.enterOuterAlt(localctx, 1)
                self.state = 215
                self.oC_Query()
                pass
            elif token in [46]:
                self.enterOuterAlt(localctx, 2)
                self.state = 216
                self.match(LcypherParser.EXPLAIN)
                self.state = 218
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 217
                    self.match(LcypherParser.SP)


                self.state = 220
                self.oC_Query()
                pass
            elif token in [47]:
                self.enterOuterAlt(localctx, 3)
                self.state = 221
                self.match(LcypherParser.PROFILE)
                self.state = 223
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 222
                    self.match(LcypherParser.SP)


                self.state = 225
                self.oC_Query()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_QueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_RegularQuery(self):
            return self.getTypedRuleContext(LcypherParser.OC_RegularQueryContext,0)


        def oC_StandaloneCall(self):
            return self.getTypedRuleContext(LcypherParser.OC_StandaloneCallContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Query

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Query" ):
                listener.enterOC_Query(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Query" ):
                listener.exitOC_Query(self)




    def oC_Query(self):

        localctx = LcypherParser.OC_QueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_oC_Query)
        try:
            self.state = 230
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 228
                self.oC_RegularQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 229
                self.oC_StandaloneCall()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RegularQueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SingleQuery(self):
            return self.getTypedRuleContext(LcypherParser.OC_SingleQueryContext,0)


        def oC_Union(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_UnionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_UnionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RegularQuery

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RegularQuery" ):
                listener.enterOC_RegularQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RegularQuery" ):
                listener.exitOC_RegularQuery(self)




    def oC_RegularQuery(self):

        localctx = LcypherParser.OC_RegularQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_oC_RegularQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.oC_SingleQuery()
            self.state = 239
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 234
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 233
                        self.match(LcypherParser.SP)


                    self.state = 236
                    self.oC_Union() 
                self.state = 241
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_UnionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UNION(self):
            return self.getToken(LcypherParser.UNION, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def ALL(self):
            return self.getToken(LcypherParser.ALL, 0)

        def oC_SingleQuery(self):
            return self.getTypedRuleContext(LcypherParser.OC_SingleQueryContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Union

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Union" ):
                listener.enterOC_Union(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Union" ):
                listener.exitOC_Union(self)




    def oC_Union(self):

        localctx = LcypherParser.OC_UnionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_oC_Union)
        self._la = 0 # Token type
        try:
            self.state = 254
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 242
                self.match(LcypherParser.UNION)
                self.state = 243
                self.match(LcypherParser.SP)
                self.state = 244
                self.match(LcypherParser.ALL)
                self.state = 246
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 245
                    self.match(LcypherParser.SP)


                self.state = 248
                self.oC_SingleQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 249
                self.match(LcypherParser.UNION)
                self.state = 251
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 250
                    self.match(LcypherParser.SP)


                self.state = 253
                self.oC_SingleQuery()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SingleQueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SinglePartQuery(self):
            return self.getTypedRuleContext(LcypherParser.OC_SinglePartQueryContext,0)


        def oC_MultiPartQuery(self):
            return self.getTypedRuleContext(LcypherParser.OC_MultiPartQueryContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_SingleQuery

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_SingleQuery" ):
                listener.enterOC_SingleQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_SingleQuery" ):
                listener.exitOC_SingleQuery(self)




    def oC_SingleQuery(self):

        localctx = LcypherParser.OC_SingleQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_oC_SingleQuery)
        try:
            self.state = 258
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 256
                self.oC_SinglePartQuery()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 257
                self.oC_MultiPartQuery()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SinglePartQueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Return(self):
            return self.getTypedRuleContext(LcypherParser.OC_ReturnContext,0)


        def oC_ReadingClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ReadingClauseContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ReadingClauseContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_UpdatingClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_UpdatingClauseContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_UpdatingClauseContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_SinglePartQuery

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_SinglePartQuery" ):
                listener.enterOC_SinglePartQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_SinglePartQuery" ):
                listener.exitOC_SinglePartQuery(self)




    def oC_SinglePartQuery(self):

        localctx = LcypherParser.OC_SinglePartQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_oC_SinglePartQuery)
        self._la = 0 # Token type
        try:
            self.state = 295
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 266
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2313724308561592320) != 0):
                    self.state = 260
                    self.oC_ReadingClause()
                    self.state = 262
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 261
                        self.match(LcypherParser.SP)


                    self.state = 268
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 269
                self.oC_Return()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 276
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2313724308561592320) != 0):
                    self.state = 270
                    self.oC_ReadingClause()
                    self.state = 272
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 271
                        self.match(LcypherParser.SP)


                    self.state = 278
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 279
                self.oC_UpdatingClause()
                self.state = 286
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 281
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 280
                            self.match(LcypherParser.SP)


                        self.state = 283
                        self.oC_UpdatingClause() 
                    self.state = 288
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,19,self._ctx)

                self.state = 293
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
                if la_ == 1:
                    self.state = 290
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 289
                        self.match(LcypherParser.SP)


                    self.state = 292
                    self.oC_Return()


                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MultiPartQueryContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SinglePartQuery(self):
            return self.getTypedRuleContext(LcypherParser.OC_SinglePartQueryContext,0)


        def oC_With(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_WithContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_WithContext,i)


        def oC_ReadingClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ReadingClauseContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ReadingClauseContext,i)


        def oC_UpdatingClause(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_UpdatingClauseContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_UpdatingClauseContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_MultiPartQuery

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_MultiPartQuery" ):
                listener.enterOC_MultiPartQuery(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_MultiPartQuery" ):
                listener.exitOC_MultiPartQuery(self)




    def oC_MultiPartQuery(self):

        localctx = LcypherParser.OC_MultiPartQueryContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_oC_MultiPartQuery)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 319 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 303
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2313724308561592320) != 0):
                        self.state = 297
                        self.oC_ReadingClause()
                        self.state = 299
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 298
                            self.match(LcypherParser.SP)


                        self.state = 305
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 312
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while (((_la) & ~0x3f) == 0 and ((1 << _la) & 2251799813685248000) != 0):
                        self.state = 306
                        self.oC_UpdatingClause()
                        self.state = 308
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 307
                            self.match(LcypherParser.SP)


                        self.state = 314
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)

                    self.state = 315
                    self.oC_With()
                    self.state = 317
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 316
                        self.match(LcypherParser.SP)



                else:
                    raise NoViableAltException(self)
                self.state = 321 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,28,self._ctx)

            self.state = 323
            self.oC_SinglePartQuery()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_UpdatingClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Create(self):
            return self.getTypedRuleContext(LcypherParser.OC_CreateContext,0)


        def oC_Merge(self):
            return self.getTypedRuleContext(LcypherParser.OC_MergeContext,0)


        def oC_Delete(self):
            return self.getTypedRuleContext(LcypherParser.OC_DeleteContext,0)


        def oC_Set(self):
            return self.getTypedRuleContext(LcypherParser.OC_SetContext,0)


        def oC_Remove(self):
            return self.getTypedRuleContext(LcypherParser.OC_RemoveContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_UpdatingClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_UpdatingClause" ):
                listener.enterOC_UpdatingClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_UpdatingClause" ):
                listener.exitOC_UpdatingClause(self)




    def oC_UpdatingClause(self):

        localctx = LcypherParser.OC_UpdatingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_oC_UpdatingClause)
        try:
            self.state = 330
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [56]:
                self.enterOuterAlt(localctx, 1)
                self.state = 325
                self.oC_Create()
                pass
            elif token in [54]:
                self.enterOuterAlt(localctx, 2)
                self.state = 326
                self.oC_Merge()
                pass
            elif token in [58, 59]:
                self.enterOuterAlt(localctx, 3)
                self.state = 327
                self.oC_Delete()
                pass
            elif token in [57]:
                self.enterOuterAlt(localctx, 4)
                self.state = 328
                self.oC_Set()
                pass
            elif token in [60]:
                self.enterOuterAlt(localctx, 5)
                self.state = 329
                self.oC_Remove()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ReadingClauseContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Match(self):
            return self.getTypedRuleContext(LcypherParser.OC_MatchContext,0)


        def oC_Unwind(self):
            return self.getTypedRuleContext(LcypherParser.OC_UnwindContext,0)


        def oC_InQueryCall(self):
            return self.getTypedRuleContext(LcypherParser.OC_InQueryCallContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ReadingClause

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ReadingClause" ):
                listener.enterOC_ReadingClause(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ReadingClause" ):
                listener.exitOC_ReadingClause(self)




    def oC_ReadingClause(self):

        localctx = LcypherParser.OC_ReadingClauseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_oC_ReadingClause)
        try:
            self.state = 335
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [50, 51]:
                self.enterOuterAlt(localctx, 1)
                self.state = 332
                self.oC_Match()
                pass
            elif token in [52]:
                self.enterOuterAlt(localctx, 2)
                self.state = 333
                self.oC_Unwind()
                pass
            elif token in [61]:
                self.enterOuterAlt(localctx, 3)
                self.state = 334
                self.oC_InQueryCall()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MatchContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MATCH(self):
            return self.getToken(LcypherParser.MATCH, 0)

        def oC_Pattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_PatternContext,0)


        def OPTIONAL_(self):
            return self.getToken(LcypherParser.OPTIONAL_, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Hint(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_HintContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_HintContext,i)


        def oC_Where(self):
            return self.getTypedRuleContext(LcypherParser.OC_WhereContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Match

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Match" ):
                listener.enterOC_Match(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Match" ):
                listener.exitOC_Match(self)




    def oC_Match(self):

        localctx = LcypherParser.OC_MatchContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_oC_Match)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 339
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==50:
                self.state = 337
                self.match(LcypherParser.OPTIONAL_)
                self.state = 338
                self.match(LcypherParser.SP)


            self.state = 341
            self.match(LcypherParser.MATCH)
            self.state = 343
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 342
                self.match(LcypherParser.SP)


            self.state = 345
            self.oC_Pattern()
            self.state = 352
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,34,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 347
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 346
                        self.match(LcypherParser.SP)


                    self.state = 349
                    self.oC_Hint() 
                self.state = 354
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

            self.state = 359
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.state = 356
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 355
                    self.match(LcypherParser.SP)


                self.state = 358
                self.oC_Where()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_UnwindContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UNWIND(self):
            return self.getToken(LcypherParser.UNWIND, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def AS(self):
            return self.getToken(LcypherParser.AS, 0)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Unwind

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Unwind" ):
                listener.enterOC_Unwind(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Unwind" ):
                listener.exitOC_Unwind(self)




    def oC_Unwind(self):

        localctx = LcypherParser.OC_UnwindContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_oC_Unwind)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.match(LcypherParser.UNWIND)
            self.state = 363
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 362
                self.match(LcypherParser.SP)


            self.state = 365
            self.oC_Expression()
            self.state = 366
            self.match(LcypherParser.SP)
            self.state = 367
            self.match(LcypherParser.AS)
            self.state = 368
            self.match(LcypherParser.SP)
            self.state = 369
            self.oC_Variable()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MergeContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def MERGE(self):
            return self.getToken(LcypherParser.MERGE, 0)

        def oC_PatternPart(self):
            return self.getTypedRuleContext(LcypherParser.OC_PatternPartContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_MergeAction(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_MergeActionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_MergeActionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Merge

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Merge" ):
                listener.enterOC_Merge(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Merge" ):
                listener.exitOC_Merge(self)




    def oC_Merge(self):

        localctx = LcypherParser.OC_MergeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_oC_Merge)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 371
            self.match(LcypherParser.MERGE)
            self.state = 373
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 372
                self.match(LcypherParser.SP)


            self.state = 375
            self.oC_PatternPart()
            self.state = 380
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,39,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 376
                    self.match(LcypherParser.SP)
                    self.state = 377
                    self.oC_MergeAction() 
                self.state = 382
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,39,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MergeActionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ON(self):
            return self.getToken(LcypherParser.ON, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def MATCH(self):
            return self.getToken(LcypherParser.MATCH, 0)

        def oC_Set(self):
            return self.getTypedRuleContext(LcypherParser.OC_SetContext,0)


        def CREATE(self):
            return self.getToken(LcypherParser.CREATE, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_MergeAction

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_MergeAction" ):
                listener.enterOC_MergeAction(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_MergeAction" ):
                listener.exitOC_MergeAction(self)




    def oC_MergeAction(self):

        localctx = LcypherParser.OC_MergeActionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_oC_MergeAction)
        try:
            self.state = 393
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 383
                self.match(LcypherParser.ON)
                self.state = 384
                self.match(LcypherParser.SP)
                self.state = 385
                self.match(LcypherParser.MATCH)
                self.state = 386
                self.match(LcypherParser.SP)
                self.state = 387
                self.oC_Set()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 388
                self.match(LcypherParser.ON)
                self.state = 389
                self.match(LcypherParser.SP)
                self.state = 390
                self.match(LcypherParser.CREATE)
                self.state = 391
                self.match(LcypherParser.SP)
                self.state = 392
                self.oC_Set()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_CreateContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CREATE(self):
            return self.getToken(LcypherParser.CREATE, 0)

        def oC_Pattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_PatternContext,0)


        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Create

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Create" ):
                listener.enterOC_Create(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Create" ):
                listener.exitOC_Create(self)




    def oC_Create(self):

        localctx = LcypherParser.OC_CreateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_oC_Create)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 395
            self.match(LcypherParser.CREATE)
            self.state = 397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 396
                self.match(LcypherParser.SP)


            self.state = 399
            self.oC_Pattern()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SetContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SET(self):
            return self.getToken(LcypherParser.SET, 0)

        def oC_SetItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_SetItemContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_SetItemContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Set

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Set" ):
                listener.enterOC_Set(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Set" ):
                listener.exitOC_Set(self)




    def oC_Set(self):

        localctx = LcypherParser.OC_SetContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_oC_Set)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            self.match(LcypherParser.SET)
            self.state = 403
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 402
                self.match(LcypherParser.SP)


            self.state = 405
            self.oC_SetItem()
            self.state = 416
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,45,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 407
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 406
                        self.match(LcypherParser.SP)


                    self.state = 409
                    self.match(LcypherParser.T__1)
                    self.state = 411
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 410
                        self.match(LcypherParser.SP)


                    self.state = 413
                    self.oC_SetItem() 
                self.state = 418
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,45,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SetItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PropertyExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertyExpressionContext,0)


        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodeLabelsContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_SetItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_SetItem" ):
                listener.enterOC_SetItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_SetItem" ):
                listener.exitOC_SetItem(self)




    def oC_SetItem(self):

        localctx = LcypherParser.OC_SetItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_oC_SetItem)
        self._la = 0 # Token type
        try:
            self.state = 455
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 419
                self.oC_PropertyExpression()
                self.state = 421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 420
                    self.match(LcypherParser.SP)


                self.state = 423
                self.match(LcypherParser.T__2)
                self.state = 425
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 424
                    self.match(LcypherParser.SP)


                self.state = 427
                self.oC_Expression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 429
                self.oC_Variable()
                self.state = 431
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 430
                    self.match(LcypherParser.SP)


                self.state = 433
                self.match(LcypherParser.T__2)
                self.state = 435
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 434
                    self.match(LcypherParser.SP)


                self.state = 437
                self.oC_Expression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 439
                self.oC_Variable()
                self.state = 441
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 440
                    self.match(LcypherParser.SP)


                self.state = 443
                self.match(LcypherParser.T__3)
                self.state = 445
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 444
                    self.match(LcypherParser.SP)


                self.state = 447
                self.oC_Expression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 449
                self.oC_Variable()
                self.state = 451
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 450
                    self.match(LcypherParser.SP)


                self.state = 453
                self.oC_NodeLabels()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_DeleteContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DELETE_(self):
            return self.getToken(LcypherParser.DELETE_, 0)

        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def DETACH(self):
            return self.getToken(LcypherParser.DETACH, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Delete

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Delete" ):
                listener.enterOC_Delete(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Delete" ):
                listener.exitOC_Delete(self)




    def oC_Delete(self):

        localctx = LcypherParser.OC_DeleteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_oC_Delete)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 459
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==58:
                self.state = 457
                self.match(LcypherParser.DETACH)
                self.state = 458
                self.match(LcypherParser.SP)


            self.state = 461
            self.match(LcypherParser.DELETE_)
            self.state = 463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 462
                self.match(LcypherParser.SP)


            self.state = 465
            self.oC_Expression()
            self.state = 476
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,58,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 467
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 466
                        self.match(LcypherParser.SP)


                    self.state = 469
                    self.match(LcypherParser.T__1)
                    self.state = 471
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 470
                        self.match(LcypherParser.SP)


                    self.state = 473
                    self.oC_Expression() 
                self.state = 478
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,58,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RemoveContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def REMOVE(self):
            return self.getToken(LcypherParser.REMOVE, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_RemoveItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_RemoveItemContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_RemoveItemContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Remove

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Remove" ):
                listener.enterOC_Remove(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Remove" ):
                listener.exitOC_Remove(self)




    def oC_Remove(self):

        localctx = LcypherParser.OC_RemoveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_oC_Remove)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 479
            self.match(LcypherParser.REMOVE)
            self.state = 480
            self.match(LcypherParser.SP)
            self.state = 481
            self.oC_RemoveItem()
            self.state = 492
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,61,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 483
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 482
                        self.match(LcypherParser.SP)


                    self.state = 485
                    self.match(LcypherParser.T__1)
                    self.state = 487
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 486
                        self.match(LcypherParser.SP)


                    self.state = 489
                    self.oC_RemoveItem() 
                self.state = 494
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RemoveItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodeLabelsContext,0)


        def oC_PropertyExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertyExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RemoveItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RemoveItem" ):
                listener.enterOC_RemoveItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RemoveItem" ):
                listener.exitOC_RemoveItem(self)




    def oC_RemoveItem(self):

        localctx = LcypherParser.OC_RemoveItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_oC_RemoveItem)
        try:
            self.state = 499
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 495
                self.oC_Variable()
                self.state = 496
                self.oC_NodeLabels()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 498
                self.oC_PropertyExpression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_InQueryCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CALL(self):
            return self.getToken(LcypherParser.CALL, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_ExplicitProcedureInvocation(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExplicitProcedureInvocationContext,0)


        def YIELD(self):
            return self.getToken(LcypherParser.YIELD, 0)

        def oC_YieldItems(self):
            return self.getTypedRuleContext(LcypherParser.OC_YieldItemsContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_InQueryCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_InQueryCall" ):
                listener.enterOC_InQueryCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_InQueryCall" ):
                listener.exitOC_InQueryCall(self)




    def oC_InQueryCall(self):

        localctx = LcypherParser.OC_InQueryCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_oC_InQueryCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 501
            self.match(LcypherParser.CALL)
            self.state = 502
            self.match(LcypherParser.SP)
            self.state = 503
            self.oC_ExplicitProcedureInvocation()
            self.state = 510
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                self.state = 505
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 504
                    self.match(LcypherParser.SP)


                self.state = 507
                self.match(LcypherParser.YIELD)
                self.state = 508
                self.match(LcypherParser.SP)
                self.state = 509
                self.oC_YieldItems()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_StandaloneCallContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def CALL(self):
            return self.getToken(LcypherParser.CALL, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_ExplicitProcedureInvocation(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExplicitProcedureInvocationContext,0)


        def oC_ImplicitProcedureInvocation(self):
            return self.getTypedRuleContext(LcypherParser.OC_ImplicitProcedureInvocationContext,0)


        def YIELD(self):
            return self.getToken(LcypherParser.YIELD, 0)

        def oC_YieldItems(self):
            return self.getTypedRuleContext(LcypherParser.OC_YieldItemsContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_StandaloneCall

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_StandaloneCall" ):
                listener.enterOC_StandaloneCall(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_StandaloneCall" ):
                listener.exitOC_StandaloneCall(self)




    def oC_StandaloneCall(self):

        localctx = LcypherParser.OC_StandaloneCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_oC_StandaloneCall)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 512
            self.match(LcypherParser.CALL)
            self.state = 513
            self.match(LcypherParser.SP)
            self.state = 516
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.state = 514
                self.oC_ExplicitProcedureInvocation()
                pass

            elif la_ == 2:
                self.state = 515
                self.oC_ImplicitProcedureInvocation()
                pass


            self.state = 522
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,66,self._ctx)
            if la_ == 1:
                self.state = 518
                self.match(LcypherParser.SP)
                self.state = 519
                self.match(LcypherParser.YIELD)
                self.state = 520
                self.match(LcypherParser.SP)
                self.state = 521
                self.oC_YieldItems()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_YieldItemsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Where(self):
            return self.getTypedRuleContext(LcypherParser.OC_WhereContext,0)


        def oC_YieldItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_YieldItemContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_YieldItemContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_YieldItems

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_YieldItems" ):
                listener.enterOC_YieldItems(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_YieldItems" ):
                listener.exitOC_YieldItems(self)




    def oC_YieldItems(self):

        localctx = LcypherParser.OC_YieldItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_oC_YieldItems)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.state = 524
                self.match(LcypherParser.T__4)
                pass
            elif token in [89, 90, 91, 92, 106, 115, 116, 117, 130]:
                self.state = 525
                self.oC_YieldItem()
                self.state = 536
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,69,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 527
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 526
                            self.match(LcypherParser.SP)


                        self.state = 529
                        self.match(LcypherParser.T__1)
                        self.state = 531
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 530
                            self.match(LcypherParser.SP)


                        self.state = 533
                        self.oC_YieldItem() 
                    self.state = 538
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,69,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

            self.state = 545
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,72,self._ctx)
            if la_ == 1:
                self.state = 542
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 541
                    self.match(LcypherParser.SP)


                self.state = 544
                self.oC_Where()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_YieldItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def oC_ProcedureResultField(self):
            return self.getTypedRuleContext(LcypherParser.OC_ProcedureResultFieldContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def AS(self):
            return self.getToken(LcypherParser.AS, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_YieldItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_YieldItem" ):
                listener.enterOC_YieldItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_YieldItem" ):
                listener.exitOC_YieldItem(self)




    def oC_YieldItem(self):

        localctx = LcypherParser.OC_YieldItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_oC_YieldItem)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 552
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 547
                self.oC_ProcedureResultField()
                self.state = 548
                self.match(LcypherParser.SP)
                self.state = 549
                self.match(LcypherParser.AS)
                self.state = 550
                self.match(LcypherParser.SP)


            self.state = 554
            self.oC_Variable()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_WithContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WITH(self):
            return self.getToken(LcypherParser.WITH, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_ReturnBody(self):
            return self.getTypedRuleContext(LcypherParser.OC_ReturnBodyContext,0)


        def DISTINCT(self):
            return self.getToken(LcypherParser.DISTINCT, 0)

        def oC_Where(self):
            return self.getTypedRuleContext(LcypherParser.OC_WhereContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_With

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_With" ):
                listener.enterOC_With(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_With" ):
                listener.exitOC_With(self)




    def oC_With(self):

        localctx = LcypherParser.OC_WithContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_oC_With)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 556
            self.match(LcypherParser.WITH)
            self.state = 561
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 558
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 557
                    self.match(LcypherParser.SP)


                self.state = 560
                self.match(LcypherParser.DISTINCT)


            self.state = 563
            self.match(LcypherParser.SP)
            self.state = 564
            self.oC_ReturnBody()
            self.state = 569
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
            if la_ == 1:
                self.state = 566
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 565
                    self.match(LcypherParser.SP)


                self.state = 568
                self.oC_Where()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ReturnContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RETURN(self):
            return self.getToken(LcypherParser.RETURN, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_ReturnBody(self):
            return self.getTypedRuleContext(LcypherParser.OC_ReturnBodyContext,0)


        def DISTINCT(self):
            return self.getToken(LcypherParser.DISTINCT, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Return

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Return" ):
                listener.enterOC_Return(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Return" ):
                listener.exitOC_Return(self)




    def oC_Return(self):

        localctx = LcypherParser.OC_ReturnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_oC_Return)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 571
            self.match(LcypherParser.RETURN)
            self.state = 576
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,79,self._ctx)
            if la_ == 1:
                self.state = 573
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 572
                    self.match(LcypherParser.SP)


                self.state = 575
                self.match(LcypherParser.DISTINCT)


            self.state = 578
            self.match(LcypherParser.SP)
            self.state = 579
            self.oC_ReturnBody()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ReturnBodyContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_ReturnItems(self):
            return self.getTypedRuleContext(LcypherParser.OC_ReturnItemsContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Order(self):
            return self.getTypedRuleContext(LcypherParser.OC_OrderContext,0)


        def oC_Skip(self):
            return self.getTypedRuleContext(LcypherParser.OC_SkipContext,0)


        def oC_Limit(self):
            return self.getTypedRuleContext(LcypherParser.OC_LimitContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ReturnBody

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ReturnBody" ):
                listener.enterOC_ReturnBody(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ReturnBody" ):
                listener.exitOC_ReturnBody(self)




    def oC_ReturnBody(self):

        localctx = LcypherParser.OC_ReturnBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_oC_ReturnBody)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 581
            self.oC_ReturnItems()
            self.state = 584
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,80,self._ctx)
            if la_ == 1:
                self.state = 582
                self.match(LcypherParser.SP)
                self.state = 583
                self.oC_Order()


            self.state = 588
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,81,self._ctx)
            if la_ == 1:
                self.state = 586
                self.match(LcypherParser.SP)
                self.state = 587
                self.oC_Skip()


            self.state = 592
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,82,self._ctx)
            if la_ == 1:
                self.state = 590
                self.match(LcypherParser.SP)
                self.state = 591
                self.oC_Limit()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ReturnItemsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_ReturnItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ReturnItemContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ReturnItemContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ReturnItems

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ReturnItems" ):
                listener.enterOC_ReturnItems(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ReturnItems" ):
                listener.exitOC_ReturnItems(self)




    def oC_ReturnItems(self):

        localctx = LcypherParser.OC_ReturnItemsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_oC_ReturnItems)
        self._la = 0 # Token type
        try:
            self.state = 622
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [5]:
                self.enterOuterAlt(localctx, 1)
                self.state = 594
                self.match(LcypherParser.T__4)
                self.state = 605
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,85,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 596
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 595
                            self.match(LcypherParser.SP)


                        self.state = 598
                        self.match(LcypherParser.T__1)
                        self.state = 600
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 599
                            self.match(LcypherParser.SP)


                        self.state = 602
                        self.oC_ReturnItem() 
                    self.state = 607
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,85,self._ctx)

                pass
            elif token in [6, 8, 13, 14, 24, 26, 49, 81, 88, 89, 90, 91, 92, 93, 94, 95, 96, 101, 103, 104, 105, 106, 113, 114, 115, 116, 117, 130]:
                self.enterOuterAlt(localctx, 2)
                self.state = 608
                self.oC_ReturnItem()
                self.state = 619
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,88,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 610
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 609
                            self.match(LcypherParser.SP)


                        self.state = 612
                        self.match(LcypherParser.T__1)
                        self.state = 614
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 613
                            self.match(LcypherParser.SP)


                        self.state = 616
                        self.oC_ReturnItem() 
                    self.state = 621
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,88,self._ctx)

                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ReturnItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def AS(self):
            return self.getToken(LcypherParser.AS, 0)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ReturnItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ReturnItem" ):
                listener.enterOC_ReturnItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ReturnItem" ):
                listener.exitOC_ReturnItem(self)




    def oC_ReturnItem(self):

        localctx = LcypherParser.OC_ReturnItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_oC_ReturnItem)
        try:
            self.state = 631
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 624
                self.oC_Expression()
                self.state = 625
                self.match(LcypherParser.SP)
                self.state = 626
                self.match(LcypherParser.AS)
                self.state = 627
                self.match(LcypherParser.SP)
                self.state = 628
                self.oC_Variable()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 630
                self.oC_Expression()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_OrderContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ORDER(self):
            return self.getToken(LcypherParser.ORDER, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def BY(self):
            return self.getToken(LcypherParser.BY, 0)

        def oC_SortItem(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_SortItemContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_SortItemContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Order

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Order" ):
                listener.enterOC_Order(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Order" ):
                listener.exitOC_Order(self)




    def oC_Order(self):

        localctx = LcypherParser.OC_OrderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_oC_Order)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 633
            self.match(LcypherParser.ORDER)
            self.state = 634
            self.match(LcypherParser.SP)
            self.state = 635
            self.match(LcypherParser.BY)
            self.state = 636
            self.match(LcypherParser.SP)
            self.state = 637
            self.oC_SortItem()
            self.state = 645
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==2:
                self.state = 638
                self.match(LcypherParser.T__1)
                self.state = 640
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 639
                    self.match(LcypherParser.SP)


                self.state = 642
                self.oC_SortItem()
                self.state = 647
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SkipContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def L_SKIP(self):
            return self.getToken(LcypherParser.L_SKIP, 0)

        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Skip

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Skip" ):
                listener.enterOC_Skip(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Skip" ):
                listener.exitOC_Skip(self)




    def oC_Skip(self):

        localctx = LcypherParser.OC_SkipContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_oC_Skip)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 648
            self.match(LcypherParser.L_SKIP)
            self.state = 649
            self.match(LcypherParser.SP)
            self.state = 650
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LimitContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LIMIT(self):
            return self.getToken(LcypherParser.LIMIT, 0)

        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Limit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Limit" ):
                listener.enterOC_Limit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Limit" ):
                listener.exitOC_Limit(self)




    def oC_Limit(self):

        localctx = LcypherParser.OC_LimitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_oC_Limit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 652
            self.match(LcypherParser.LIMIT)
            self.state = 653
            self.match(LcypherParser.SP)
            self.state = 654
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SortItemContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def ASCENDING(self):
            return self.getToken(LcypherParser.ASCENDING, 0)

        def ASC(self):
            return self.getToken(LcypherParser.ASC, 0)

        def DESCENDING(self):
            return self.getToken(LcypherParser.DESCENDING, 0)

        def DESC(self):
            return self.getToken(LcypherParser.DESC, 0)

        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_SortItem

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_SortItem" ):
                listener.enterOC_SortItem(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_SortItem" ):
                listener.exitOC_SortItem(self)




    def oC_SortItem(self):

        localctx = LcypherParser.OC_SortItemContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_oC_SortItem)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 656
            self.oC_Expression()
            self.state = 661
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
            if la_ == 1:
                self.state = 658
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 657
                    self.match(LcypherParser.SP)


                self.state = 660
                _la = self._input.LA(1)
                if not(((((_la - 70)) & ~0x3f) == 0 and ((1 << (_la - 70)) & 15) != 0)):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_HintContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def USING(self):
            return self.getToken(LcypherParser.USING, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def JOIN(self):
            return self.getToken(LcypherParser.JOIN, 0)

        def ON(self):
            return self.getToken(LcypherParser.ON, 0)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def START(self):
            return self.getToken(LcypherParser.START, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Hint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Hint" ):
                listener.enterOC_Hint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Hint" ):
                listener.exitOC_Hint(self)




    def oC_Hint(self):

        localctx = LcypherParser.OC_HintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_oC_Hint)
        try:
            self.state = 677
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,95,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 663
                self.match(LcypherParser.USING)
                self.state = 664
                self.match(LcypherParser.SP)
                self.state = 665
                self.match(LcypherParser.JOIN)
                self.state = 666
                self.match(LcypherParser.SP)
                self.state = 667
                self.match(LcypherParser.ON)
                self.state = 668
                self.match(LcypherParser.SP)
                self.state = 669
                self.oC_Variable()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 670
                self.match(LcypherParser.USING)
                self.state = 671
                self.match(LcypherParser.SP)
                self.state = 672
                self.match(LcypherParser.START)
                self.state = 673
                self.match(LcypherParser.SP)
                self.state = 674
                self.match(LcypherParser.ON)
                self.state = 675
                self.match(LcypherParser.SP)
                self.state = 676
                self.oC_Variable()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_WhereContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHERE(self):
            return self.getToken(LcypherParser.WHERE, 0)

        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Where

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Where" ):
                listener.enterOC_Where(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Where" ):
                listener.exitOC_Where(self)




    def oC_Where(self):

        localctx = LcypherParser.OC_WhereContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_oC_Where)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 679
            self.match(LcypherParser.WHERE)
            self.state = 680
            self.match(LcypherParser.SP)
            self.state = 681
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PatternPart(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PatternPartContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PatternPartContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Pattern

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Pattern" ):
                listener.enterOC_Pattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Pattern" ):
                listener.exitOC_Pattern(self)




    def oC_Pattern(self):

        localctx = LcypherParser.OC_PatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_oC_Pattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 683
            self.oC_PatternPart()
            self.state = 694
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,98,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 685
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 684
                        self.match(LcypherParser.SP)


                    self.state = 687
                    self.match(LcypherParser.T__1)
                    self.state = 689
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 688
                        self.match(LcypherParser.SP)


                    self.state = 691
                    self.oC_PatternPart() 
                self.state = 696
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,98,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternPartContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def oC_AnonymousPatternPart(self):
            return self.getTypedRuleContext(LcypherParser.OC_AnonymousPatternPartContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PatternPart

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PatternPart" ):
                listener.enterOC_PatternPart(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PatternPart" ):
                listener.exitOC_PatternPart(self)




    def oC_PatternPart(self):

        localctx = LcypherParser.OC_PatternPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_oC_PatternPart)
        self._la = 0 # Token type
        try:
            self.state = 708
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89, 90, 91, 92, 106, 115, 116, 117, 130]:
                self.enterOuterAlt(localctx, 1)
                self.state = 697
                self.oC_Variable()
                self.state = 699
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 698
                    self.match(LcypherParser.SP)


                self.state = 701
                self.match(LcypherParser.T__2)
                self.state = 703
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 702
                    self.match(LcypherParser.SP)


                self.state = 705
                self.oC_AnonymousPatternPart()
                pass
            elif token in [6]:
                self.enterOuterAlt(localctx, 2)
                self.state = 707
                self.oC_AnonymousPatternPart()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_AnonymousPatternPartContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PatternElement(self):
            return self.getTypedRuleContext(LcypherParser.OC_PatternElementContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_AnonymousPatternPart

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_AnonymousPatternPart" ):
                listener.enterOC_AnonymousPatternPart(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_AnonymousPatternPart" ):
                listener.exitOC_AnonymousPatternPart(self)




    def oC_AnonymousPatternPart(self):

        localctx = LcypherParser.OC_AnonymousPatternPartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_oC_AnonymousPatternPart)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 710
            self.oC_PatternElement()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternElementContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_NodePattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodePatternContext,0)


        def oC_PatternElementChain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PatternElementChainContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PatternElementChainContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_PatternElement(self):
            return self.getTypedRuleContext(LcypherParser.OC_PatternElementContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PatternElement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PatternElement" ):
                listener.enterOC_PatternElement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PatternElement" ):
                listener.exitOC_PatternElement(self)




    def oC_PatternElement(self):

        localctx = LcypherParser.OC_PatternElementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_oC_PatternElement)
        self._la = 0 # Token type
        try:
            self.state = 726
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,104,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 712
                self.oC_NodePattern()
                self.state = 719
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,103,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 714
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 713
                            self.match(LcypherParser.SP)


                        self.state = 716
                        self.oC_PatternElementChain() 
                    self.state = 721
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,103,self._ctx)

                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 722
                self.match(LcypherParser.T__5)
                self.state = 723
                self.oC_PatternElement()
                self.state = 724
                self.match(LcypherParser.T__6)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NodePatternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodeLabelsContext,0)


        def oC_Properties(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertiesContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_NodePattern

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_NodePattern" ):
                listener.enterOC_NodePattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_NodePattern" ):
                listener.exitOC_NodePattern(self)




    def oC_NodePattern(self):

        localctx = LcypherParser.OC_NodePatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_oC_NodePattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 728
            self.match(LcypherParser.T__5)
            self.state = 730
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 729
                self.match(LcypherParser.SP)


            self.state = 736
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 2199493148687) != 0):
                self.state = 732
                self.oC_Variable()
                self.state = 734
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 733
                    self.match(LcypherParser.SP)




            self.state = 742
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 738
                self.oC_NodeLabels()
                self.state = 740
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 739
                    self.match(LcypherParser.SP)




            self.state = 748
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==24 or _la==26:
                self.state = 744
                self.oC_Properties()
                self.state = 746
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 745
                    self.match(LcypherParser.SP)




            self.state = 750
            self.match(LcypherParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternElementChainContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_RelationshipPattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_RelationshipPatternContext,0)


        def oC_NodePattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodePatternContext,0)


        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PatternElementChain

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PatternElementChain" ):
                listener.enterOC_PatternElementChain(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PatternElementChain" ):
                listener.exitOC_PatternElementChain(self)




    def oC_PatternElementChain(self):

        localctx = LcypherParser.OC_PatternElementChainContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_oC_PatternElementChain)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 752
            self.oC_RelationshipPattern()
            self.state = 754
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 753
                self.match(LcypherParser.SP)


            self.state = 756
            self.oC_NodePattern()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RelationshipPatternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_LeftArrowHead(self):
            return self.getTypedRuleContext(LcypherParser.OC_LeftArrowHeadContext,0)


        def oC_Dash(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_DashContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_DashContext,i)


        def oC_RightArrowHead(self):
            return self.getTypedRuleContext(LcypherParser.OC_RightArrowHeadContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_RelationshipDetail(self):
            return self.getTypedRuleContext(LcypherParser.OC_RelationshipDetailContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RelationshipPattern

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RelationshipPattern" ):
                listener.enterOC_RelationshipPattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RelationshipPattern" ):
                listener.exitOC_RelationshipPattern(self)




    def oC_RelationshipPattern(self):

        localctx = LcypherParser.OC_RelationshipPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_oC_RelationshipPattern)
        self._la = 0 # Token type
        try:
            self.state = 822
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,129,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 758
                self.oC_LeftArrowHead()
                self.state = 760
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 759
                    self.match(LcypherParser.SP)


                self.state = 762
                self.oC_Dash()
                self.state = 764
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
                if la_ == 1:
                    self.state = 763
                    self.match(LcypherParser.SP)


                self.state = 767
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 766
                    self.oC_RelationshipDetail()


                self.state = 770
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 769
                    self.match(LcypherParser.SP)


                self.state = 772
                self.oC_Dash()
                self.state = 774
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 773
                    self.match(LcypherParser.SP)


                self.state = 776
                self.oC_RightArrowHead()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 778
                self.oC_LeftArrowHead()
                self.state = 780
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 779
                    self.match(LcypherParser.SP)


                self.state = 782
                self.oC_Dash()
                self.state = 784
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,119,self._ctx)
                if la_ == 1:
                    self.state = 783
                    self.match(LcypherParser.SP)


                self.state = 787
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 786
                    self.oC_RelationshipDetail()


                self.state = 790
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 789
                    self.match(LcypherParser.SP)


                self.state = 792
                self.oC_Dash()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 794
                self.oC_Dash()
                self.state = 796
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,122,self._ctx)
                if la_ == 1:
                    self.state = 795
                    self.match(LcypherParser.SP)


                self.state = 799
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 798
                    self.oC_RelationshipDetail()


                self.state = 802
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 801
                    self.match(LcypherParser.SP)


                self.state = 804
                self.oC_Dash()
                self.state = 806
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 805
                    self.match(LcypherParser.SP)


                self.state = 808
                self.oC_RightArrowHead()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 810
                self.oC_Dash()
                self.state = 812
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,126,self._ctx)
                if la_ == 1:
                    self.state = 811
                    self.match(LcypherParser.SP)


                self.state = 815
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==8:
                    self.state = 814
                    self.oC_RelationshipDetail()


                self.state = 818
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 817
                    self.match(LcypherParser.SP)


                self.state = 820
                self.oC_Dash()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RelationshipDetailContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def oC_RelationshipTypes(self):
            return self.getTypedRuleContext(LcypherParser.OC_RelationshipTypesContext,0)


        def oC_RangeLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_RangeLiteralContext,0)


        def oC_Properties(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertiesContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RelationshipDetail

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RelationshipDetail" ):
                listener.enterOC_RelationshipDetail(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RelationshipDetail" ):
                listener.exitOC_RelationshipDetail(self)




    def oC_RelationshipDetail(self):

        localctx = LcypherParser.OC_RelationshipDetailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_oC_RelationshipDetail)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 824
            self.match(LcypherParser.T__7)
            self.state = 826
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 825
                self.match(LcypherParser.SP)


            self.state = 832
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 2199493148687) != 0):
                self.state = 828
                self.oC_Variable()
                self.state = 830
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 829
                    self.match(LcypherParser.SP)




            self.state = 838
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==10:
                self.state = 834
                self.oC_RelationshipTypes()
                self.state = 836
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 835
                    self.match(LcypherParser.SP)




            self.state = 841
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==5:
                self.state = 840
                self.oC_RangeLiteral()


            self.state = 847
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==24 or _la==26:
                self.state = 843
                self.oC_Properties()
                self.state = 845
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 844
                    self.match(LcypherParser.SP)




            self.state = 849
            self.match(LcypherParser.T__8)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertiesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_MapLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_MapLiteralContext,0)


        def oC_Parameter(self):
            return self.getTypedRuleContext(LcypherParser.OC_ParameterContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Properties

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Properties" ):
                listener.enterOC_Properties(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Properties" ):
                listener.exitOC_Properties(self)




    def oC_Properties(self):

        localctx = LcypherParser.OC_PropertiesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_oC_Properties)
        try:
            self.state = 853
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [24]:
                self.enterOuterAlt(localctx, 1)
                self.state = 851
                self.oC_MapLiteral()
                pass
            elif token in [26]:
                self.enterOuterAlt(localctx, 2)
                self.state = 852
                self.oC_Parameter()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RelationshipTypesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_RelTypeName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_RelTypeNameContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_RelTypeNameContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RelationshipTypes

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RelationshipTypes" ):
                listener.enterOC_RelationshipTypes(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RelationshipTypes" ):
                listener.exitOC_RelationshipTypes(self)




    def oC_RelationshipTypes(self):

        localctx = LcypherParser.OC_RelationshipTypesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_oC_RelationshipTypes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 855
            self.match(LcypherParser.T__9)
            self.state = 857
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 856
                self.match(LcypherParser.SP)


            self.state = 859
            self.oC_RelTypeName()
            self.state = 873
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,143,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 861
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 860
                        self.match(LcypherParser.SP)


                    self.state = 863
                    self.match(LcypherParser.T__10)
                    self.state = 865
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==10:
                        self.state = 864
                        self.match(LcypherParser.T__9)


                    self.state = 868
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 867
                        self.match(LcypherParser.SP)


                    self.state = 870
                    self.oC_RelTypeName() 
                self.state = 875
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,143,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NodeLabelsContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_NodeLabel(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_NodeLabelContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_NodeLabelContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_NodeLabels

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_NodeLabels" ):
                listener.enterOC_NodeLabels(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_NodeLabels" ):
                listener.exitOC_NodeLabels(self)




    def oC_NodeLabels(self):

        localctx = LcypherParser.OC_NodeLabelsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_oC_NodeLabels)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 876
            self.oC_NodeLabel()
            self.state = 883
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,145,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 878
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 877
                        self.match(LcypherParser.SP)


                    self.state = 880
                    self.oC_NodeLabel() 
                self.state = 885
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,145,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NodeLabelContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_LabelName(self):
            return self.getTypedRuleContext(LcypherParser.OC_LabelNameContext,0)


        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_NodeLabel

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_NodeLabel" ):
                listener.enterOC_NodeLabel(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_NodeLabel" ):
                listener.exitOC_NodeLabel(self)




    def oC_NodeLabel(self):

        localctx = LcypherParser.OC_NodeLabelContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_oC_NodeLabel)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 886
            self.match(LcypherParser.T__9)
            self.state = 888
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 887
                self.match(LcypherParser.SP)


            self.state = 890
            self.oC_LabelName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RangeLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_IntegerLiteral(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_IntegerLiteralContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_IntegerLiteralContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RangeLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RangeLiteral" ):
                listener.enterOC_RangeLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RangeLiteral" ):
                listener.exitOC_RangeLiteral(self)




    def oC_RangeLiteral(self):

        localctx = LcypherParser.OC_RangeLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_oC_RangeLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 892
            self.match(LcypherParser.T__4)
            self.state = 894
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 893
                self.match(LcypherParser.SP)


            self.state = 900
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & 7) != 0):
                self.state = 896
                self.oC_IntegerLiteral()
                self.state = 898
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 897
                    self.match(LcypherParser.SP)




            self.state = 912
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==12:
                self.state = 902
                self.match(LcypherParser.T__11)
                self.state = 904
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 903
                    self.match(LcypherParser.SP)


                self.state = 910
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if ((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & 7) != 0):
                    self.state = 906
                    self.oC_IntegerLiteral()
                    self.state = 908
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 907
                        self.match(LcypherParser.SP)






        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LabelNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SchemaName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SchemaNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_LabelName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_LabelName" ):
                listener.enterOC_LabelName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_LabelName" ):
                listener.exitOC_LabelName(self)




    def oC_LabelName(self):

        localctx = LcypherParser.OC_LabelNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_oC_LabelName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 914
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RelTypeNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SchemaName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SchemaNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RelTypeName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RelTypeName" ):
                listener.enterOC_RelTypeName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RelTypeName" ):
                listener.exitOC_RelTypeName(self)




    def oC_RelTypeName(self):

        localctx = LcypherParser.OC_RelTypeNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_oC_RelTypeName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 916
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_OrExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_OrExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Expression" ):
                listener.enterOC_Expression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Expression" ):
                listener.exitOC_Expression(self)




    def oC_Expression(self):

        localctx = LcypherParser.OC_ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_oC_Expression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 918
            self.oC_OrExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_OrExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_XorExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_XorExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_XorExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def OR(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.OR)
            else:
                return self.getToken(LcypherParser.OR, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_OrExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_OrExpression" ):
                listener.enterOC_OrExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_OrExpression" ):
                listener.exitOC_OrExpression(self)




    def oC_OrExpression(self):

        localctx = LcypherParser.OC_OrExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_oC_OrExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 920
            self.oC_XorExpression()
            self.state = 927
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,154,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 921
                    self.match(LcypherParser.SP)
                    self.state = 922
                    self.match(LcypherParser.OR)
                    self.state = 923
                    self.match(LcypherParser.SP)
                    self.state = 924
                    self.oC_XorExpression() 
                self.state = 929
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,154,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_XorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_AndExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_AndExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_AndExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def XOR(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.XOR)
            else:
                return self.getToken(LcypherParser.XOR, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_XorExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_XorExpression" ):
                listener.enterOC_XorExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_XorExpression" ):
                listener.exitOC_XorExpression(self)




    def oC_XorExpression(self):

        localctx = LcypherParser.OC_XorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_oC_XorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 930
            self.oC_AndExpression()
            self.state = 937
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,155,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 931
                    self.match(LcypherParser.SP)
                    self.state = 932
                    self.match(LcypherParser.XOR)
                    self.state = 933
                    self.match(LcypherParser.SP)
                    self.state = 934
                    self.oC_AndExpression() 
                self.state = 939
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,155,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_AndExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_NotExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_NotExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_NotExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def AND(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.AND)
            else:
                return self.getToken(LcypherParser.AND, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_AndExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_AndExpression" ):
                listener.enterOC_AndExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_AndExpression" ):
                listener.exitOC_AndExpression(self)




    def oC_AndExpression(self):

        localctx = LcypherParser.OC_AndExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_oC_AndExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 940
            self.oC_NotExpression()
            self.state = 947
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,156,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 941
                    self.match(LcypherParser.SP)
                    self.state = 942
                    self.match(LcypherParser.AND)
                    self.state = 943
                    self.match(LcypherParser.SP)
                    self.state = 944
                    self.oC_NotExpression() 
                self.state = 949
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,156,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NotExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_ComparisonExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ComparisonExpressionContext,0)


        def NOT(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.NOT)
            else:
                return self.getToken(LcypherParser.NOT, i)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_NotExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_NotExpression" ):
                listener.enterOC_NotExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_NotExpression" ):
                listener.exitOC_NotExpression(self)




    def oC_NotExpression(self):

        localctx = LcypherParser.OC_NotExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_oC_NotExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 956
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==81:
                self.state = 950
                self.match(LcypherParser.NOT)
                self.state = 952
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 951
                    self.match(LcypherParser.SP)


                self.state = 958
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 959
            self.oC_ComparisonExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_AddOrSubtractExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_AddOrSubtractExpressionContext,0)


        def oC_PartialComparisonExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PartialComparisonExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PartialComparisonExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ComparisonExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ComparisonExpression" ):
                listener.enterOC_ComparisonExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ComparisonExpression" ):
                listener.exitOC_ComparisonExpression(self)




    def oC_ComparisonExpression(self):

        localctx = LcypherParser.OC_ComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_oC_ComparisonExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 961
            self.oC_AddOrSubtractExpression()
            self.state = 968
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,160,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 963
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 962
                        self.match(LcypherParser.SP)


                    self.state = 965
                    self.oC_PartialComparisonExpression() 
                self.state = 970
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,160,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_AddOrSubtractExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_MultiplyDivideModuloExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_MultiplyDivideModuloExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_MultiplyDivideModuloExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_AddOrSubtractExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_AddOrSubtractExpression" ):
                listener.enterOC_AddOrSubtractExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_AddOrSubtractExpression" ):
                listener.exitOC_AddOrSubtractExpression(self)




    def oC_AddOrSubtractExpression(self):

        localctx = LcypherParser.OC_AddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_oC_AddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 971
            self.oC_MultiplyDivideModuloExpression()
            self.state = 990
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,166,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 988
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,165,self._ctx)
                    if la_ == 1:
                        self.state = 973
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 972
                            self.match(LcypherParser.SP)


                        self.state = 975
                        self.match(LcypherParser.T__12)
                        self.state = 977
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 976
                            self.match(LcypherParser.SP)


                        self.state = 979
                        self.oC_MultiplyDivideModuloExpression()
                        pass

                    elif la_ == 2:
                        self.state = 981
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 980
                            self.match(LcypherParser.SP)


                        self.state = 983
                        self.match(LcypherParser.T__13)
                        self.state = 985
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 984
                            self.match(LcypherParser.SP)


                        self.state = 987
                        self.oC_MultiplyDivideModuloExpression()
                        pass

             
                self.state = 992
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,166,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MultiplyDivideModuloExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PowerOfExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PowerOfExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PowerOfExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_MultiplyDivideModuloExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_MultiplyDivideModuloExpression" ):
                listener.enterOC_MultiplyDivideModuloExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_MultiplyDivideModuloExpression" ):
                listener.exitOC_MultiplyDivideModuloExpression(self)




    def oC_MultiplyDivideModuloExpression(self):

        localctx = LcypherParser.OC_MultiplyDivideModuloExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_oC_MultiplyDivideModuloExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 993
            self.oC_PowerOfExpression()
            self.state = 1020
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,174,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1018
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,173,self._ctx)
                    if la_ == 1:
                        self.state = 995
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 994
                            self.match(LcypherParser.SP)


                        self.state = 997
                        self.match(LcypherParser.T__4)
                        self.state = 999
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 998
                            self.match(LcypherParser.SP)


                        self.state = 1001
                        self.oC_PowerOfExpression()
                        pass

                    elif la_ == 2:
                        self.state = 1003
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 1002
                            self.match(LcypherParser.SP)


                        self.state = 1005
                        self.match(LcypherParser.T__14)
                        self.state = 1007
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 1006
                            self.match(LcypherParser.SP)


                        self.state = 1009
                        self.oC_PowerOfExpression()
                        pass

                    elif la_ == 3:
                        self.state = 1011
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 1010
                            self.match(LcypherParser.SP)


                        self.state = 1013
                        self.match(LcypherParser.T__15)
                        self.state = 1015
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 1014
                            self.match(LcypherParser.SP)


                        self.state = 1017
                        self.oC_PowerOfExpression()
                        pass

             
                self.state = 1022
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,174,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PowerOfExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_UnaryAddOrSubtractExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_UnaryAddOrSubtractExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_UnaryAddOrSubtractExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PowerOfExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PowerOfExpression" ):
                listener.enterOC_PowerOfExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PowerOfExpression" ):
                listener.exitOC_PowerOfExpression(self)




    def oC_PowerOfExpression(self):

        localctx = LcypherParser.OC_PowerOfExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_oC_PowerOfExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1023
            self.oC_UnaryAddOrSubtractExpression()
            self.state = 1034
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,177,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1025
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1024
                        self.match(LcypherParser.SP)


                    self.state = 1027
                    self.match(LcypherParser.T__16)
                    self.state = 1029
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1028
                        self.match(LcypherParser.SP)


                    self.state = 1031
                    self.oC_UnaryAddOrSubtractExpression() 
                self.state = 1036
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,177,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_UnaryAddOrSubtractExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_StringListNullOperatorExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_StringListNullOperatorExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_UnaryAddOrSubtractExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_UnaryAddOrSubtractExpression" ):
                listener.enterOC_UnaryAddOrSubtractExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_UnaryAddOrSubtractExpression" ):
                listener.exitOC_UnaryAddOrSubtractExpression(self)




    def oC_UnaryAddOrSubtractExpression(self):

        localctx = LcypherParser.OC_UnaryAddOrSubtractExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_oC_UnaryAddOrSubtractExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1043
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==13 or _la==14:
                self.state = 1037
                _la = self._input.LA(1)
                if not(_la==13 or _la==14):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 1039
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1038
                    self.match(LcypherParser.SP)


                self.state = 1045
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 1046
            self.oC_StringListNullOperatorExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_StringListNullOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PropertyOrLabelsExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertyOrLabelsExpressionContext,0)


        def oC_StringOperatorExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_StringOperatorExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_StringOperatorExpressionContext,i)


        def oC_ListOperatorExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ListOperatorExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ListOperatorExpressionContext,i)


        def oC_NullOperatorExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_NullOperatorExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_NullOperatorExpressionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_StringListNullOperatorExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_StringListNullOperatorExpression" ):
                listener.enterOC_StringListNullOperatorExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_StringListNullOperatorExpression" ):
                listener.exitOC_StringListNullOperatorExpression(self)




    def oC_StringListNullOperatorExpression(self):

        localctx = LcypherParser.OC_StringListNullOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_oC_StringListNullOperatorExpression)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1048
            self.oC_PropertyOrLabelsExpression()
            self.state = 1054
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,181,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1052
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,180,self._ctx)
                    if la_ == 1:
                        self.state = 1049
                        self.oC_StringOperatorExpression()
                        pass

                    elif la_ == 2:
                        self.state = 1050
                        self.oC_ListOperatorExpression()
                        pass

                    elif la_ == 3:
                        self.state = 1051
                        self.oC_NullOperatorExpression()
                        pass

             
                self.state = 1056
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,181,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ListOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def IN(self):
            return self.getToken(LcypherParser.IN, 0)

        def oC_PropertyOrLabelsExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertyOrLabelsExpressionContext,0)


        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ListOperatorExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ListOperatorExpression" ):
                listener.enterOC_ListOperatorExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ListOperatorExpression" ):
                listener.exitOC_ListOperatorExpression(self)




    def oC_ListOperatorExpression(self):

        localctx = LcypherParser.OC_ListOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_oC_ListOperatorExpression)
        self._la = 0 # Token type
        try:
            self.state = 1082
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,187,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1057
                self.match(LcypherParser.SP)
                self.state = 1058
                self.match(LcypherParser.IN)
                self.state = 1060
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1059
                    self.match(LcypherParser.SP)


                self.state = 1062
                self.oC_PropertyOrLabelsExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1064
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1063
                    self.match(LcypherParser.SP)


                self.state = 1066
                self.match(LcypherParser.T__7)
                self.state = 1067
                self.oC_Expression()
                self.state = 1068
                self.match(LcypherParser.T__8)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1071
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1070
                    self.match(LcypherParser.SP)


                self.state = 1073
                self.match(LcypherParser.T__7)
                self.state = 1075
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 562950037332288) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 563083161436033) != 0):
                    self.state = 1074
                    self.oC_Expression()


                self.state = 1077
                self.match(LcypherParser.T__11)
                self.state = 1079
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & 562950037332288) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 563083161436033) != 0):
                    self.state = 1078
                    self.oC_Expression()


                self.state = 1081
                self.match(LcypherParser.T__8)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_StringOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PropertyOrLabelsExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertyOrLabelsExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def STARTS(self):
            return self.getToken(LcypherParser.STARTS, 0)

        def WITH(self):
            return self.getToken(LcypherParser.WITH, 0)

        def ENDS(self):
            return self.getToken(LcypherParser.ENDS, 0)

        def CONTAINS(self):
            return self.getToken(LcypherParser.CONTAINS, 0)

        def REGEXP(self):
            return self.getToken(LcypherParser.REGEXP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_StringOperatorExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_StringOperatorExpression" ):
                listener.enterOC_StringOperatorExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_StringOperatorExpression" ):
                listener.exitOC_StringOperatorExpression(self)




    def oC_StringOperatorExpression(self):

        localctx = LcypherParser.OC_StringOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_oC_StringOperatorExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1096
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,188,self._ctx)
            if la_ == 1:
                self.state = 1084
                self.match(LcypherParser.SP)
                self.state = 1085
                self.match(LcypherParser.STARTS)
                self.state = 1086
                self.match(LcypherParser.SP)
                self.state = 1087
                self.match(LcypherParser.WITH)
                pass

            elif la_ == 2:
                self.state = 1088
                self.match(LcypherParser.SP)
                self.state = 1089
                self.match(LcypherParser.ENDS)
                self.state = 1090
                self.match(LcypherParser.SP)
                self.state = 1091
                self.match(LcypherParser.WITH)
                pass

            elif la_ == 3:
                self.state = 1092
                self.match(LcypherParser.SP)
                self.state = 1093
                self.match(LcypherParser.CONTAINS)
                pass

            elif la_ == 4:
                self.state = 1094
                self.match(LcypherParser.SP)
                self.state = 1095
                self.match(LcypherParser.REGEXP)
                pass


            self.state = 1099
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1098
                self.match(LcypherParser.SP)


            self.state = 1101
            self.oC_PropertyOrLabelsExpression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NullOperatorExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def IS(self):
            return self.getToken(LcypherParser.IS, 0)

        def NULL_(self):
            return self.getToken(LcypherParser.NULL_, 0)

        def NOT(self):
            return self.getToken(LcypherParser.NOT, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_NullOperatorExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_NullOperatorExpression" ):
                listener.enterOC_NullOperatorExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_NullOperatorExpression" ):
                listener.exitOC_NullOperatorExpression(self)




    def oC_NullOperatorExpression(self):

        localctx = LcypherParser.OC_NullOperatorExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_oC_NullOperatorExpression)
        try:
            self.state = 1113
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,190,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1103
                self.match(LcypherParser.SP)
                self.state = 1104
                self.match(LcypherParser.IS)
                self.state = 1105
                self.match(LcypherParser.SP)
                self.state = 1106
                self.match(LcypherParser.NULL_)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1107
                self.match(LcypherParser.SP)
                self.state = 1108
                self.match(LcypherParser.IS)
                self.state = 1109
                self.match(LcypherParser.SP)
                self.state = 1110
                self.match(LcypherParser.NOT)
                self.state = 1111
                self.match(LcypherParser.SP)
                self.state = 1112
                self.match(LcypherParser.NULL_)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertyOrLabelsExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Atom(self):
            return self.getTypedRuleContext(LcypherParser.OC_AtomContext,0)


        def oC_PropertyLookup(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PropertyLookupContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PropertyLookupContext,i)


        def oC_NodeLabels(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodeLabelsContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PropertyOrLabelsExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PropertyOrLabelsExpression" ):
                listener.enterOC_PropertyOrLabelsExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PropertyOrLabelsExpression" ):
                listener.exitOC_PropertyOrLabelsExpression(self)




    def oC_PropertyOrLabelsExpression(self):

        localctx = LcypherParser.OC_PropertyOrLabelsExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_oC_PropertyOrLabelsExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1115
            self.oC_Atom()
            self.state = 1122
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,192,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1117
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1116
                        self.match(LcypherParser.SP)


                    self.state = 1119
                    self.oC_PropertyLookup() 
                self.state = 1124
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,192,self._ctx)

            self.state = 1129
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,194,self._ctx)
            if la_ == 1:
                self.state = 1126
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1125
                    self.match(LcypherParser.SP)


                self.state = 1128
                self.oC_NodeLabels()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_AtomContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Literal(self):
            return self.getTypedRuleContext(LcypherParser.OC_LiteralContext,0)


        def oC_Parameter(self):
            return self.getTypedRuleContext(LcypherParser.OC_ParameterContext,0)


        def oC_CaseExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_CaseExpressionContext,0)


        def COUNT(self):
            return self.getToken(LcypherParser.COUNT, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_ListComprehension(self):
            return self.getTypedRuleContext(LcypherParser.OC_ListComprehensionContext,0)


        def oC_PatternComprehension(self):
            return self.getTypedRuleContext(LcypherParser.OC_PatternComprehensionContext,0)


        def ALL(self):
            return self.getToken(LcypherParser.ALL, 0)

        def oC_FilterExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_FilterExpressionContext,0)


        def ANY(self):
            return self.getToken(LcypherParser.ANY, 0)

        def NONE(self):
            return self.getToken(LcypherParser.NONE, 0)

        def SINGLE(self):
            return self.getToken(LcypherParser.SINGLE, 0)

        def oC_RelationshipsPattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_RelationshipsPatternContext,0)


        def oC_ParenthesizedExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ParenthesizedExpressionContext,0)


        def oC_FunctionInvocation(self):
            return self.getTypedRuleContext(LcypherParser.OC_FunctionInvocationContext,0)


        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Atom

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Atom" ):
                listener.enterOC_Atom(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Atom" ):
                listener.exitOC_Atom(self)




    def oC_Atom(self):

        localctx = LcypherParser.OC_AtomContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_oC_Atom)
        self._la = 0 # Token type
        try:
            self.state = 1209
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,210,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 1131
                self.oC_Literal()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 1132
                self.oC_Parameter()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 1133
                self.oC_CaseExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 1134
                self.match(LcypherParser.COUNT)
                self.state = 1136
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1135
                    self.match(LcypherParser.SP)


                self.state = 1138
                self.match(LcypherParser.T__5)
                self.state = 1140
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1139
                    self.match(LcypherParser.SP)


                self.state = 1142
                self.match(LcypherParser.T__4)
                self.state = 1144
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1143
                    self.match(LcypherParser.SP)


                self.state = 1146
                self.match(LcypherParser.T__6)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 1147
                self.oC_ListComprehension()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 1148
                self.oC_PatternComprehension()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 1149
                self.match(LcypherParser.ALL)
                self.state = 1151
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1150
                    self.match(LcypherParser.SP)


                self.state = 1153
                self.match(LcypherParser.T__5)
                self.state = 1155
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1154
                    self.match(LcypherParser.SP)


                self.state = 1157
                self.oC_FilterExpression()
                self.state = 1159
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1158
                    self.match(LcypherParser.SP)


                self.state = 1161
                self.match(LcypherParser.T__6)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 1163
                self.match(LcypherParser.ANY)
                self.state = 1165
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1164
                    self.match(LcypherParser.SP)


                self.state = 1167
                self.match(LcypherParser.T__5)
                self.state = 1169
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1168
                    self.match(LcypherParser.SP)


                self.state = 1171
                self.oC_FilterExpression()
                self.state = 1173
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1172
                    self.match(LcypherParser.SP)


                self.state = 1175
                self.match(LcypherParser.T__6)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 1177
                self.match(LcypherParser.NONE)
                self.state = 1179
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1178
                    self.match(LcypherParser.SP)


                self.state = 1181
                self.match(LcypherParser.T__5)
                self.state = 1183
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1182
                    self.match(LcypherParser.SP)


                self.state = 1185
                self.oC_FilterExpression()
                self.state = 1187
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1186
                    self.match(LcypherParser.SP)


                self.state = 1189
                self.match(LcypherParser.T__6)
                pass

            elif la_ == 10:
                self.enterOuterAlt(localctx, 10)
                self.state = 1191
                self.match(LcypherParser.SINGLE)
                self.state = 1193
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1192
                    self.match(LcypherParser.SP)


                self.state = 1195
                self.match(LcypherParser.T__5)
                self.state = 1197
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1196
                    self.match(LcypherParser.SP)


                self.state = 1199
                self.oC_FilterExpression()
                self.state = 1201
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1200
                    self.match(LcypherParser.SP)


                self.state = 1203
                self.match(LcypherParser.T__6)
                pass

            elif la_ == 11:
                self.enterOuterAlt(localctx, 11)
                self.state = 1205
                self.oC_RelationshipsPattern()
                pass

            elif la_ == 12:
                self.enterOuterAlt(localctx, 12)
                self.state = 1206
                self.oC_ParenthesizedExpression()
                pass

            elif la_ == 13:
                self.enterOuterAlt(localctx, 13)
                self.state = 1207
                self.oC_FunctionInvocation()
                pass

            elif la_ == 14:
                self.enterOuterAlt(localctx, 14)
                self.state = 1208
                self.oC_Variable()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_NumberLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_NumberLiteralContext,0)


        def StringLiteral(self):
            return self.getToken(LcypherParser.StringLiteral, 0)

        def oC_BooleanLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_BooleanLiteralContext,0)


        def NULL_(self):
            return self.getToken(LcypherParser.NULL_, 0)

        def oC_MapLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_MapLiteralContext,0)


        def oC_ListLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_ListLiteralContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Literal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Literal" ):
                listener.enterOC_Literal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Literal" ):
                listener.exitOC_Literal(self)




    def oC_Literal(self):

        localctx = LcypherParser.OC_LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_oC_Literal)
        try:
            self.state = 1217
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [103, 104, 105, 113, 114]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1211
                self.oC_NumberLiteral()
                pass
            elif token in [101]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1212
                self.match(LcypherParser.StringLiteral)
                pass
            elif token in [93, 94]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1213
                self.oC_BooleanLiteral()
                pass
            elif token in [88]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1214
                self.match(LcypherParser.NULL_)
                pass
            elif token in [24]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1215
                self.oC_MapLiteral()
                pass
            elif token in [8]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1216
                self.oC_ListLiteral()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_BooleanLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def TRUE_(self):
            return self.getToken(LcypherParser.TRUE_, 0)

        def FALSE_(self):
            return self.getToken(LcypherParser.FALSE_, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_BooleanLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_BooleanLiteral" ):
                listener.enterOC_BooleanLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_BooleanLiteral" ):
                listener.exitOC_BooleanLiteral(self)




    def oC_BooleanLiteral(self):

        localctx = LcypherParser.OC_BooleanLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_oC_BooleanLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1219
            _la = self._input.LA(1)
            if not(_la==93 or _la==94):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ListLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ListLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ListLiteral" ):
                listener.enterOC_ListLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ListLiteral" ):
                listener.exitOC_ListLiteral(self)




    def oC_ListLiteral(self):

        localctx = LcypherParser.OC_ListLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_oC_ListLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1221
            self.match(LcypherParser.T__7)
            self.state = 1223
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1222
                self.match(LcypherParser.SP)


            self.state = 1242
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 562950037332288) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 563083161436033) != 0):
                self.state = 1225
                self.oC_Expression()
                self.state = 1227
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1226
                    self.match(LcypherParser.SP)


                self.state = 1239
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1229
                    self.match(LcypherParser.T__1)
                    self.state = 1231
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1230
                        self.match(LcypherParser.SP)


                    self.state = 1233
                    self.oC_Expression()
                    self.state = 1235
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1234
                        self.match(LcypherParser.SP)


                    self.state = 1241
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1244
            self.match(LcypherParser.T__8)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PartialComparisonExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_AddOrSubtractExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_AddOrSubtractExpressionContext,0)


        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PartialComparisonExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PartialComparisonExpression" ):
                listener.enterOC_PartialComparisonExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PartialComparisonExpression" ):
                listener.exitOC_PartialComparisonExpression(self)




    def oC_PartialComparisonExpression(self):

        localctx = LcypherParser.OC_PartialComparisonExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_oC_PartialComparisonExpression)
        self._la = 0 # Token type
        try:
            self.state = 1276
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [3]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1246
                self.match(LcypherParser.T__2)
                self.state = 1248
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1247
                    self.match(LcypherParser.SP)


                self.state = 1250
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [18]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1251
                self.match(LcypherParser.T__17)
                self.state = 1253
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1252
                    self.match(LcypherParser.SP)


                self.state = 1255
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [19]:
                self.enterOuterAlt(localctx, 3)
                self.state = 1256
                self.match(LcypherParser.T__18)
                self.state = 1258
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1257
                    self.match(LcypherParser.SP)


                self.state = 1260
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [20]:
                self.enterOuterAlt(localctx, 4)
                self.state = 1261
                self.match(LcypherParser.T__19)
                self.state = 1263
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1262
                    self.match(LcypherParser.SP)


                self.state = 1265
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [21]:
                self.enterOuterAlt(localctx, 5)
                self.state = 1266
                self.match(LcypherParser.T__20)
                self.state = 1268
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1267
                    self.match(LcypherParser.SP)


                self.state = 1270
                self.oC_AddOrSubtractExpression()
                pass
            elif token in [22]:
                self.enterOuterAlt(localctx, 6)
                self.state = 1271
                self.match(LcypherParser.T__21)
                self.state = 1273
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1272
                    self.match(LcypherParser.SP)


                self.state = 1275
                self.oC_AddOrSubtractExpression()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ParenthesizedExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ParenthesizedExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ParenthesizedExpression" ):
                listener.enterOC_ParenthesizedExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ParenthesizedExpression" ):
                listener.exitOC_ParenthesizedExpression(self)




    def oC_ParenthesizedExpression(self):

        localctx = LcypherParser.OC_ParenthesizedExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_oC_ParenthesizedExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1278
            self.match(LcypherParser.T__5)
            self.state = 1280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1279
                self.match(LcypherParser.SP)


            self.state = 1282
            self.oC_Expression()
            self.state = 1284
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1283
                self.match(LcypherParser.SP)


            self.state = 1286
            self.match(LcypherParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RelationshipsPatternContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_NodePattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_NodePatternContext,0)


        def oC_PatternElementChain(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PatternElementChainContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PatternElementChainContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RelationshipsPattern

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RelationshipsPattern" ):
                listener.enterOC_RelationshipsPattern(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RelationshipsPattern" ):
                listener.exitOC_RelationshipsPattern(self)




    def oC_RelationshipsPattern(self):

        localctx = LcypherParser.OC_RelationshipsPatternContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_oC_RelationshipsPattern)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1288
            self.oC_NodePattern()
            self.state = 1293 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1290
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1289
                        self.match(LcypherParser.SP)


                    self.state = 1292
                    self.oC_PatternElementChain()

                else:
                    raise NoViableAltException(self)
                self.state = 1295 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,228,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_FilterExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_IdInColl(self):
            return self.getTypedRuleContext(LcypherParser.OC_IdInCollContext,0)


        def oC_Where(self):
            return self.getTypedRuleContext(LcypherParser.OC_WhereContext,0)


        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_FilterExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_FilterExpression" ):
                listener.enterOC_FilterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_FilterExpression" ):
                listener.exitOC_FilterExpression(self)




    def oC_FilterExpression(self):

        localctx = LcypherParser.OC_FilterExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_oC_FilterExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1297
            self.oC_IdInColl()
            self.state = 1302
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,230,self._ctx)
            if la_ == 1:
                self.state = 1299
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1298
                    self.match(LcypherParser.SP)


                self.state = 1301
                self.oC_Where()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_IdInCollContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def IN(self):
            return self.getToken(LcypherParser.IN, 0)

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_IdInColl

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_IdInColl" ):
                listener.enterOC_IdInColl(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_IdInColl" ):
                listener.exitOC_IdInColl(self)




    def oC_IdInColl(self):

        localctx = LcypherParser.OC_IdInCollContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_oC_IdInColl)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1304
            self.oC_Variable()
            self.state = 1305
            self.match(LcypherParser.SP)
            self.state = 1306
            self.match(LcypherParser.IN)
            self.state = 1307
            self.match(LcypherParser.SP)
            self.state = 1308
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_FunctionInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_FunctionName(self):
            return self.getTypedRuleContext(LcypherParser.OC_FunctionNameContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def DISTINCT(self):
            return self.getToken(LcypherParser.DISTINCT, 0)

        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_FunctionInvocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_FunctionInvocation" ):
                listener.enterOC_FunctionInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_FunctionInvocation" ):
                listener.exitOC_FunctionInvocation(self)




    def oC_FunctionInvocation(self):

        localctx = LcypherParser.OC_FunctionInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_oC_FunctionInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1310
            self.oC_FunctionName()
            self.state = 1312
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1311
                self.match(LcypherParser.SP)


            self.state = 1314
            self.match(LcypherParser.T__5)
            self.state = 1316
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1315
                self.match(LcypherParser.SP)


            self.state = 1322
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==64:
                self.state = 1318
                self.match(LcypherParser.DISTINCT)
                self.state = 1320
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1319
                    self.match(LcypherParser.SP)




            self.state = 1341
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 562950037332288) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 563083161436033) != 0):
                self.state = 1324
                self.oC_Expression()
                self.state = 1326
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1325
                    self.match(LcypherParser.SP)


                self.state = 1338
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1328
                    self.match(LcypherParser.T__1)
                    self.state = 1330
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1329
                        self.match(LcypherParser.SP)


                    self.state = 1332
                    self.oC_Expression()
                    self.state = 1334
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1333
                        self.match(LcypherParser.SP)


                    self.state = 1340
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1343
            self.match(LcypherParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_FunctionNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Namespace(self):
            return self.getTypedRuleContext(LcypherParser.OC_NamespaceContext,0)


        def oC_SymbolicName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,0)


        def EXISTS(self):
            return self.getToken(LcypherParser.EXISTS, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_FunctionName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_FunctionName" ):
                listener.enterOC_FunctionName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_FunctionName" ):
                listener.exitOC_FunctionName(self)




    def oC_FunctionName(self):

        localctx = LcypherParser.OC_FunctionNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_oC_FunctionName)
        try:
            self.state = 1349
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89, 90, 91, 92, 106, 115, 116, 117, 130]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1345
                self.oC_Namespace()
                self.state = 1346
                self.oC_SymbolicName()
                pass
            elif token in [95]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1348
                self.match(LcypherParser.EXISTS)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ExplicitProcedureInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_ProcedureName(self):
            return self.getTypedRuleContext(LcypherParser.OC_ProcedureNameContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ExplicitProcedureInvocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ExplicitProcedureInvocation" ):
                listener.enterOC_ExplicitProcedureInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ExplicitProcedureInvocation" ):
                listener.exitOC_ExplicitProcedureInvocation(self)




    def oC_ExplicitProcedureInvocation(self):

        localctx = LcypherParser.OC_ExplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_oC_ExplicitProcedureInvocation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1351
            self.oC_ProcedureName()
            self.state = 1353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1352
                self.match(LcypherParser.SP)


            self.state = 1355
            self.match(LcypherParser.T__5)
            self.state = 1357
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1356
                self.match(LcypherParser.SP)


            self.state = 1376
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & 562950037332288) != 0) or ((((_la - 81)) & ~0x3f) == 0 and ((1 << (_la - 81)) & 563083161436033) != 0):
                self.state = 1359
                self.oC_Expression()
                self.state = 1361
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1360
                    self.match(LcypherParser.SP)


                self.state = 1373
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1363
                    self.match(LcypherParser.T__1)
                    self.state = 1365
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1364
                        self.match(LcypherParser.SP)


                    self.state = 1367
                    self.oC_Expression()
                    self.state = 1369
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1368
                        self.match(LcypherParser.SP)


                    self.state = 1375
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1378
            self.match(LcypherParser.T__6)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ImplicitProcedureInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_ProcedureName(self):
            return self.getTypedRuleContext(LcypherParser.OC_ProcedureNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ImplicitProcedureInvocation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ImplicitProcedureInvocation" ):
                listener.enterOC_ImplicitProcedureInvocation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ImplicitProcedureInvocation" ):
                listener.exitOC_ImplicitProcedureInvocation(self)




    def oC_ImplicitProcedureInvocation(self):

        localctx = LcypherParser.OC_ImplicitProcedureInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_oC_ImplicitProcedureInvocation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1380
            self.oC_ProcedureName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProcedureResultFieldContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ProcedureResultField

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ProcedureResultField" ):
                listener.enterOC_ProcedureResultField(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ProcedureResultField" ):
                listener.exitOC_ProcedureResultField(self)




    def oC_ProcedureResultField(self):

        localctx = LcypherParser.OC_ProcedureResultFieldContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_oC_ProcedureResultField)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1382
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ProcedureNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Namespace(self):
            return self.getTypedRuleContext(LcypherParser.OC_NamespaceContext,0)


        def oC_SymbolicName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ProcedureName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ProcedureName" ):
                listener.enterOC_ProcedureName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ProcedureName" ):
                listener.exitOC_ProcedureName(self)




    def oC_ProcedureName(self):

        localctx = LcypherParser.OC_ProcedureNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_oC_ProcedureName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1384
            self.oC_Namespace()
            self.state = 1385
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NamespaceContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SymbolicName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_SymbolicNameContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Namespace

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Namespace" ):
                listener.enterOC_Namespace(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Namespace" ):
                listener.exitOC_Namespace(self)




    def oC_Namespace(self):

        localctx = LcypherParser.OC_NamespaceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_oC_Namespace)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1392
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,248,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 1387
                    self.oC_SymbolicName()
                    self.state = 1388
                    self.match(LcypherParser.T__22) 
                self.state = 1394
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,248,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ListComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_FilterExpression(self):
            return self.getTypedRuleContext(LcypherParser.OC_FilterExpressionContext,0)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Expression(self):
            return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ListComprehension

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ListComprehension" ):
                listener.enterOC_ListComprehension(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ListComprehension" ):
                listener.exitOC_ListComprehension(self)




    def oC_ListComprehension(self):

        localctx = LcypherParser.OC_ListComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 162, self.RULE_oC_ListComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1395
            self.match(LcypherParser.T__7)
            self.state = 1397
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1396
                self.match(LcypherParser.SP)


            self.state = 1399
            self.oC_FilterExpression()
            self.state = 1408
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,252,self._ctx)
            if la_ == 1:
                self.state = 1401
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1400
                    self.match(LcypherParser.SP)


                self.state = 1403
                self.match(LcypherParser.T__10)
                self.state = 1405
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1404
                    self.match(LcypherParser.SP)


                self.state = 1407
                self.oC_Expression()


            self.state = 1411
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1410
                self.match(LcypherParser.SP)


            self.state = 1413
            self.match(LcypherParser.T__8)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PatternComprehensionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_RelationshipsPattern(self):
            return self.getTypedRuleContext(LcypherParser.OC_RelationshipsPatternContext,0)


        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_Variable(self):
            return self.getTypedRuleContext(LcypherParser.OC_VariableContext,0)


        def WHERE(self):
            return self.getToken(LcypherParser.WHERE, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PatternComprehension

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PatternComprehension" ):
                listener.enterOC_PatternComprehension(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PatternComprehension" ):
                listener.exitOC_PatternComprehension(self)




    def oC_PatternComprehension(self):

        localctx = LcypherParser.OC_PatternComprehensionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 164, self.RULE_oC_PatternComprehension)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1415
            self.match(LcypherParser.T__7)
            self.state = 1417
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1416
                self.match(LcypherParser.SP)


            self.state = 1427
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 2199493148687) != 0):
                self.state = 1419
                self.oC_Variable()
                self.state = 1421
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1420
                    self.match(LcypherParser.SP)


                self.state = 1423
                self.match(LcypherParser.T__2)
                self.state = 1425
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1424
                    self.match(LcypherParser.SP)




            self.state = 1429
            self.oC_RelationshipsPattern()
            self.state = 1431
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1430
                self.match(LcypherParser.SP)


            self.state = 1441
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==77:
                self.state = 1433
                self.match(LcypherParser.WHERE)
                self.state = 1435
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1434
                    self.match(LcypherParser.SP)


                self.state = 1437
                self.oC_Expression()
                self.state = 1439
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1438
                    self.match(LcypherParser.SP)




            self.state = 1443
            self.match(LcypherParser.T__10)
            self.state = 1445
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1444
                self.match(LcypherParser.SP)


            self.state = 1447
            self.oC_Expression()
            self.state = 1449
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1448
                self.match(LcypherParser.SP)


            self.state = 1451
            self.match(LcypherParser.T__8)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertyLookupContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_PropertyKeyName(self):
            return self.getTypedRuleContext(LcypherParser.OC_PropertyKeyNameContext,0)


        def SP(self):
            return self.getToken(LcypherParser.SP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PropertyLookup

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PropertyLookup" ):
                listener.enterOC_PropertyLookup(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PropertyLookup" ):
                listener.exitOC_PropertyLookup(self)




    def oC_PropertyLookup(self):

        localctx = LcypherParser.OC_PropertyLookupContext(self, self._ctx, self.state)
        self.enterRule(localctx, 166, self.RULE_oC_PropertyLookup)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1453
            self.match(LcypherParser.T__22)
            self.state = 1455
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1454
                self.match(LcypherParser.SP)


            self.state = 1457
            self.oC_PropertyKeyName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_CaseExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def END(self):
            return self.getToken(LcypherParser.END, 0)

        def ELSE(self):
            return self.getToken(LcypherParser.ELSE, 0)

        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def CASE(self):
            return self.getToken(LcypherParser.CASE, 0)

        def oC_CaseAlternatives(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_CaseAlternativesContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_CaseAlternativesContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_CaseExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_CaseExpression" ):
                listener.enterOC_CaseExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_CaseExpression" ):
                listener.exitOC_CaseExpression(self)




    def oC_CaseExpression(self):

        localctx = LcypherParser.OC_CaseExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 168, self.RULE_oC_CaseExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1481
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,270,self._ctx)
            if la_ == 1:
                self.state = 1459
                self.match(LcypherParser.CASE)
                self.state = 1464 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1461
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 1460
                            self.match(LcypherParser.SP)


                        self.state = 1463
                        self.oC_CaseAlternatives()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1466 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,266,self._ctx)

                pass

            elif la_ == 2:
                self.state = 1468
                self.match(LcypherParser.CASE)
                self.state = 1470
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1469
                    self.match(LcypherParser.SP)


                self.state = 1472
                self.oC_Expression()
                self.state = 1477 
                self._errHandler.sync(self)
                _alt = 1
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt == 1:
                        self.state = 1474
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==131:
                            self.state = 1473
                            self.match(LcypherParser.SP)


                        self.state = 1476
                        self.oC_CaseAlternatives()

                    else:
                        raise NoViableAltException(self)
                    self.state = 1479 
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,269,self._ctx)

                pass


            self.state = 1491
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,273,self._ctx)
            if la_ == 1:
                self.state = 1484
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1483
                    self.match(LcypherParser.SP)


                self.state = 1486
                self.match(LcypherParser.ELSE)
                self.state = 1488
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1487
                    self.match(LcypherParser.SP)


                self.state = 1490
                self.oC_Expression()


            self.state = 1494
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1493
                self.match(LcypherParser.SP)


            self.state = 1496
            self.match(LcypherParser.END)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_CaseAlternativesContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def WHEN(self):
            return self.getToken(LcypherParser.WHEN, 0)

        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def THEN(self):
            return self.getToken(LcypherParser.THEN, 0)

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_CaseAlternatives

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_CaseAlternatives" ):
                listener.enterOC_CaseAlternatives(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_CaseAlternatives" ):
                listener.exitOC_CaseAlternatives(self)




    def oC_CaseAlternatives(self):

        localctx = LcypherParser.OC_CaseAlternativesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 170, self.RULE_oC_CaseAlternatives)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1498
            self.match(LcypherParser.WHEN)
            self.state = 1500
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1499
                self.match(LcypherParser.SP)


            self.state = 1502
            self.oC_Expression()
            self.state = 1504
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1503
                self.match(LcypherParser.SP)


            self.state = 1506
            self.match(LcypherParser.THEN)
            self.state = 1508
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1507
                self.match(LcypherParser.SP)


            self.state = 1510
            self.oC_Expression()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_VariableContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Variable

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Variable" ):
                listener.enterOC_Variable(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Variable" ):
                listener.exitOC_Variable(self)




    def oC_Variable(self):

        localctx = LcypherParser.OC_VariableContext(self, self._ctx, self.state)
        self.enterRule(localctx, 172, self.RULE_oC_Variable)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1512
            self.oC_SymbolicName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_NumberLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_DoubleLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_DoubleLiteralContext,0)


        def oC_IntegerLiteral(self):
            return self.getTypedRuleContext(LcypherParser.OC_IntegerLiteralContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_NumberLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_NumberLiteral" ):
                listener.enterOC_NumberLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_NumberLiteral" ):
                listener.exitOC_NumberLiteral(self)




    def oC_NumberLiteral(self):

        localctx = LcypherParser.OC_NumberLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 174, self.RULE_oC_NumberLiteral)
        try:
            self.state = 1516
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [113, 114]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1514
                self.oC_DoubleLiteral()
                pass
            elif token in [103, 104, 105]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1515
                self.oC_IntegerLiteral()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_MapLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def oC_PropertyKeyName(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PropertyKeyNameContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PropertyKeyNameContext,i)


        def oC_Expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_ExpressionContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_ExpressionContext,i)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_MapLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_MapLiteral" ):
                listener.enterOC_MapLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_MapLiteral" ):
                listener.exitOC_MapLiteral(self)




    def oC_MapLiteral(self):

        localctx = LcypherParser.OC_MapLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 176, self.RULE_oC_MapLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1518
            self.match(LcypherParser.T__23)
            self.state = 1520
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==131:
                self.state = 1519
                self.match(LcypherParser.SP)


            self.state = 1555
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 48)) & ~0x3f) == 0 and ((1 << (_la - 48)) & 297237300058759167) != 0) or ((((_la - 115)) & ~0x3f) == 0 and ((1 << (_la - 115)) & 40959) != 0):
                self.state = 1522
                self.oC_PropertyKeyName()
                self.state = 1524
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1523
                    self.match(LcypherParser.SP)


                self.state = 1526
                self.match(LcypherParser.T__9)
                self.state = 1528
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1527
                    self.match(LcypherParser.SP)


                self.state = 1530
                self.oC_Expression()
                self.state = 1532
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==131:
                    self.state = 1531
                    self.match(LcypherParser.SP)


                self.state = 1552
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==2:
                    self.state = 1534
                    self.match(LcypherParser.T__1)
                    self.state = 1536
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1535
                        self.match(LcypherParser.SP)


                    self.state = 1538
                    self.oC_PropertyKeyName()
                    self.state = 1540
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1539
                        self.match(LcypherParser.SP)


                    self.state = 1542
                    self.match(LcypherParser.T__9)
                    self.state = 1544
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1543
                        self.match(LcypherParser.SP)


                    self.state = 1546
                    self.oC_Expression()
                    self.state = 1548
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1547
                        self.match(LcypherParser.SP)


                    self.state = 1554
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 1557
            self.match(LcypherParser.T__24)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ParameterContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,0)


        def DecimalInteger(self):
            return self.getToken(LcypherParser.DecimalInteger, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Parameter

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Parameter" ):
                listener.enterOC_Parameter(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Parameter" ):
                listener.exitOC_Parameter(self)




    def oC_Parameter(self):

        localctx = LcypherParser.OC_ParameterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 178, self.RULE_oC_Parameter)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1559
            self.match(LcypherParser.T__25)
            self.state = 1562
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89, 90, 91, 92, 106, 115, 116, 117, 130]:
                self.state = 1560
                self.oC_SymbolicName()
                pass
            elif token in [104]:
                self.state = 1561
                self.match(LcypherParser.DecimalInteger)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertyExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_Atom(self):
            return self.getTypedRuleContext(LcypherParser.OC_AtomContext,0)


        def oC_PropertyLookup(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(LcypherParser.OC_PropertyLookupContext)
            else:
                return self.getTypedRuleContext(LcypherParser.OC_PropertyLookupContext,i)


        def SP(self, i:int=None):
            if i is None:
                return self.getTokens(LcypherParser.SP)
            else:
                return self.getToken(LcypherParser.SP, i)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PropertyExpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PropertyExpression" ):
                listener.enterOC_PropertyExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PropertyExpression" ):
                listener.exitOC_PropertyExpression(self)




    def oC_PropertyExpression(self):

        localctx = LcypherParser.OC_PropertyExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 180, self.RULE_oC_PropertyExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1564
            self.oC_Atom()
            self.state = 1569 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 1566
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==131:
                        self.state = 1565
                        self.match(LcypherParser.SP)


                    self.state = 1568
                    self.oC_PropertyLookup()

                else:
                    raise NoViableAltException(self)
                self.state = 1571 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,291,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_PropertyKeyNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SchemaName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SchemaNameContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_PropertyKeyName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_PropertyKeyName" ):
                listener.enterOC_PropertyKeyName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_PropertyKeyName" ):
                listener.exitOC_PropertyKeyName(self)




    def oC_PropertyKeyName(self):

        localctx = LcypherParser.OC_PropertyKeyNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 182, self.RULE_oC_PropertyKeyName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1573
            self.oC_SchemaName()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_IntegerLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def HexInteger(self):
            return self.getToken(LcypherParser.HexInteger, 0)

        def OctalInteger(self):
            return self.getToken(LcypherParser.OctalInteger, 0)

        def DecimalInteger(self):
            return self.getToken(LcypherParser.DecimalInteger, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_IntegerLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_IntegerLiteral" ):
                listener.enterOC_IntegerLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_IntegerLiteral" ):
                listener.exitOC_IntegerLiteral(self)




    def oC_IntegerLiteral(self):

        localctx = LcypherParser.OC_IntegerLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 184, self.RULE_oC_IntegerLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1575
            _la = self._input.LA(1)
            if not(((((_la - 103)) & ~0x3f) == 0 and ((1 << (_la - 103)) & 7) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_DoubleLiteralContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ExponentDecimalReal(self):
            return self.getToken(LcypherParser.ExponentDecimalReal, 0)

        def RegularDecimalReal(self):
            return self.getToken(LcypherParser.RegularDecimalReal, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_DoubleLiteral

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_DoubleLiteral" ):
                listener.enterOC_DoubleLiteral(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_DoubleLiteral" ):
                listener.exitOC_DoubleLiteral(self)




    def oC_DoubleLiteral(self):

        localctx = LcypherParser.OC_DoubleLiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 186, self.RULE_oC_DoubleLiteral)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1577
            _la = self._input.LA(1)
            if not(_la==113 or _la==114):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SchemaNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def oC_SymbolicName(self):
            return self.getTypedRuleContext(LcypherParser.OC_SymbolicNameContext,0)


        def oC_ReservedWord(self):
            return self.getTypedRuleContext(LcypherParser.OC_ReservedWordContext,0)


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_SchemaName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_SchemaName" ):
                listener.enterOC_SchemaName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_SchemaName" ):
                listener.exitOC_SchemaName(self)




    def oC_SchemaName(self):

        localctx = LcypherParser.OC_SchemaNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 188, self.RULE_oC_SchemaName)
        try:
            self.state = 1581
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [89, 90, 91, 92, 106, 115, 116, 117, 130]:
                self.enterOuterAlt(localctx, 1)
                self.state = 1579
                self.oC_SymbolicName()
                pass
            elif token in [48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 77, 78, 79, 80, 81, 82, 83, 84, 85, 87, 88, 93, 94, 95, 96, 97, 98, 99, 100, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127]:
                self.enterOuterAlt(localctx, 2)
                self.state = 1580
                self.oC_ReservedWord()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_SymbolicNameContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UnescapedSymbolicName(self):
            return self.getToken(LcypherParser.UnescapedSymbolicName, 0)

        def EscapedSymbolicName(self):
            return self.getToken(LcypherParser.EscapedSymbolicName, 0)

        def HexLetter(self):
            return self.getToken(LcypherParser.HexLetter, 0)

        def COUNT(self):
            return self.getToken(LcypherParser.COUNT, 0)

        def FILTER(self):
            return self.getToken(LcypherParser.FILTER, 0)

        def EXTRACT(self):
            return self.getToken(LcypherParser.EXTRACT, 0)

        def ANY(self):
            return self.getToken(LcypherParser.ANY, 0)

        def NONE(self):
            return self.getToken(LcypherParser.NONE, 0)

        def SINGLE(self):
            return self.getToken(LcypherParser.SINGLE, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_SymbolicName

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_SymbolicName" ):
                listener.enterOC_SymbolicName(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_SymbolicName" ):
                listener.exitOC_SymbolicName(self)




    def oC_SymbolicName(self):

        localctx = LcypherParser.OC_SymbolicNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 190, self.RULE_oC_SymbolicName)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1583
            _la = self._input.LA(1)
            if not(((((_la - 89)) & ~0x3f) == 0 and ((1 << (_la - 89)) & 2199493148687) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_ReservedWordContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def ALL(self):
            return self.getToken(LcypherParser.ALL, 0)

        def ASC(self):
            return self.getToken(LcypherParser.ASC, 0)

        def ASCENDING(self):
            return self.getToken(LcypherParser.ASCENDING, 0)

        def BY(self):
            return self.getToken(LcypherParser.BY, 0)

        def CREATE(self):
            return self.getToken(LcypherParser.CREATE, 0)

        def DELETE_(self):
            return self.getToken(LcypherParser.DELETE_, 0)

        def DESC(self):
            return self.getToken(LcypherParser.DESC, 0)

        def DESCENDING(self):
            return self.getToken(LcypherParser.DESCENDING, 0)

        def DETACH(self):
            return self.getToken(LcypherParser.DETACH, 0)

        def EXISTS(self):
            return self.getToken(LcypherParser.EXISTS, 0)

        def LIMIT(self):
            return self.getToken(LcypherParser.LIMIT, 0)

        def MATCH(self):
            return self.getToken(LcypherParser.MATCH, 0)

        def MERGE(self):
            return self.getToken(LcypherParser.MERGE, 0)

        def ON(self):
            return self.getToken(LcypherParser.ON, 0)

        def OPTIONAL_(self):
            return self.getToken(LcypherParser.OPTIONAL_, 0)

        def ORDER(self):
            return self.getToken(LcypherParser.ORDER, 0)

        def REMOVE(self):
            return self.getToken(LcypherParser.REMOVE, 0)

        def RETURN(self):
            return self.getToken(LcypherParser.RETURN, 0)

        def SET(self):
            return self.getToken(LcypherParser.SET, 0)

        def L_SKIP(self):
            return self.getToken(LcypherParser.L_SKIP, 0)

        def WHERE(self):
            return self.getToken(LcypherParser.WHERE, 0)

        def WITH(self):
            return self.getToken(LcypherParser.WITH, 0)

        def UNION(self):
            return self.getToken(LcypherParser.UNION, 0)

        def UNWIND(self):
            return self.getToken(LcypherParser.UNWIND, 0)

        def AND(self):
            return self.getToken(LcypherParser.AND, 0)

        def AS(self):
            return self.getToken(LcypherParser.AS, 0)

        def CONTAINS(self):
            return self.getToken(LcypherParser.CONTAINS, 0)

        def DISTINCT(self):
            return self.getToken(LcypherParser.DISTINCT, 0)

        def ENDS(self):
            return self.getToken(LcypherParser.ENDS, 0)

        def IN(self):
            return self.getToken(LcypherParser.IN, 0)

        def IS(self):
            return self.getToken(LcypherParser.IS, 0)

        def NOT(self):
            return self.getToken(LcypherParser.NOT, 0)

        def OR(self):
            return self.getToken(LcypherParser.OR, 0)

        def STARTS(self):
            return self.getToken(LcypherParser.STARTS, 0)

        def XOR(self):
            return self.getToken(LcypherParser.XOR, 0)

        def FALSE_(self):
            return self.getToken(LcypherParser.FALSE_, 0)

        def TRUE_(self):
            return self.getToken(LcypherParser.TRUE_, 0)

        def NULL_(self):
            return self.getToken(LcypherParser.NULL_, 0)

        def CONSTRAINT(self):
            return self.getToken(LcypherParser.CONSTRAINT, 0)

        def DO(self):
            return self.getToken(LcypherParser.DO, 0)

        def FOR(self):
            return self.getToken(LcypherParser.FOR, 0)

        def REQUIRE(self):
            return self.getToken(LcypherParser.REQUIRE, 0)

        def UNIQUE(self):
            return self.getToken(LcypherParser.UNIQUE, 0)

        def CASE(self):
            return self.getToken(LcypherParser.CASE, 0)

        def WHEN(self):
            return self.getToken(LcypherParser.WHEN, 0)

        def THEN(self):
            return self.getToken(LcypherParser.THEN, 0)

        def ELSE(self):
            return self.getToken(LcypherParser.ELSE, 0)

        def END(self):
            return self.getToken(LcypherParser.END, 0)

        def MANDATORY(self):
            return self.getToken(LcypherParser.MANDATORY, 0)

        def SCALAR(self):
            return self.getToken(LcypherParser.SCALAR, 0)

        def OF(self):
            return self.getToken(LcypherParser.OF, 0)

        def ADD(self):
            return self.getToken(LcypherParser.ADD, 0)

        def DROP(self):
            return self.getToken(LcypherParser.DROP, 0)

        def getRuleIndex(self):
            return LcypherParser.RULE_oC_ReservedWord

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_ReservedWord" ):
                listener.enterOC_ReservedWord(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_ReservedWord" ):
                listener.exitOC_ReservedWord(self)




    def oC_ReservedWord(self):

        localctx = LcypherParser.OC_ReservedWordContext(self, self._ctx, self.state)
        self.enterRule(localctx, 192, self.RULE_oC_ReservedWord)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1585
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & -6917810502617792512) != 0) or ((((_la - 64)) & ~0x3f) == 0 and ((1 << (_la - 64)) & -18014261578046465) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_LeftArrowHeadContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_LeftArrowHead

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_LeftArrowHead" ):
                listener.enterOC_LeftArrowHead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_LeftArrowHead" ):
                listener.exitOC_LeftArrowHead(self)




    def oC_LeftArrowHead(self):

        localctx = LcypherParser.OC_LeftArrowHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 194, self.RULE_oC_LeftArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1587
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 2013790208) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_RightArrowHeadContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_RightArrowHead

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_RightArrowHead" ):
                listener.enterOC_RightArrowHead(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_RightArrowHead" ):
                listener.exitOC_RightArrowHead(self)




    def oC_RightArrowHead(self):

        localctx = LcypherParser.OC_RightArrowHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 196, self.RULE_oC_RightArrowHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1589
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 32213303296) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OC_DashContext(ParserRuleContext):
        __slots__ = 'parser'

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser


        def getRuleIndex(self):
            return LcypherParser.RULE_oC_Dash

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOC_Dash" ):
                listener.enterOC_Dash(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOC_Dash" ):
                listener.exitOC_Dash(self)




    def oC_Dash(self):

        localctx = LcypherParser.OC_DashContext(self, self._ctx, self.state)
        self.enterRule(localctx, 198, self.RULE_oC_Dash)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 1591
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & 70334384455680) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





